deadvey/mathgenerator
1
0
Fork 0
mirror of https://github.com/DeaDvey/mathgenerator.git synced 2025-11-28 06:25:23 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #5 from Todarith/master

Browse Source 
Sync head
This commit is contained in:
Luke Weiler
2020-10-16 20:12:30 -04:00
committed by GitHub
parent ed03295563 751a5d23ad
commit 2f02dde539
10 changed files with 786 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
.github/workflows/tests.yaml vendored Normal file
View File

@@ -0,0 +1,21 @@
name: Run tests
on: [push, pull_request]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: '3.x'
- name: Install dependencies
run: |
python -m pip install -U pip
python -m pip install -r dev-requirements.txt
- name: Test
run: make test

138
.gitignore vendored Normal file
View File

@@ -0,0 +1,138 @@
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
*.py,cover
.hypothesis/
.pytest_cache/
cover/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
db.sqlite3
db.sqlite3-journal
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
.pybuilder/
target/
# Jupyter Notebook
.ipynb_checkpoints
# IPython
profile_default/
ipython_config.py
# pyenv
# For a library or package, you might want to ignore these files since the code is
# intended to run in multiple environments; otherwise, check them in:
# .python-version
# pipenv
# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
# However, in case of collaboration, if having platform-specific dependencies or dependencies
# having no cross-platform support, pipenv may install dependencies that don't work, or not
# install all needed dependencies.
#Pipfile.lock
# PEP 582; used by e.g. github.com/David-OConnor/pyflow
__pypackages__/
# Celery stuff
celerybeat-schedule
celerybeat.pid
# SageMath parsed files
*.sage.py
# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
.dmypy.json
dmypy.json
# Pyre type checker
.pyre/
# pytype static type analyzer
.pytype/
# Cython debug symbols
cython_debug/

2
Makefile Normal file
View File

@@ -0,0 +1,2 @@
test:
python -m pytest --verbose -s tests

51
README.md
View File

@@ -1,37 +1,50 @@
# mathgenerator
A math problem generator, created for the purpose of giving self-studying students and teaching organizations the means to easily get access to random math problems to suit their needs.
To try out generators, go to https://todarith.ml/generate/
To try out generators, go to <https://todarith.ml/generate/>
If you have an idea for a generator, please add it as an issue and tag it with the "New Generator" label.
## Usage
The project can be install via pip
```
```bash
pip install mathgenerator
```
Here is an example of how you would generate an addition problem:
```
```python
from mathgenerator import mathgen
#generate an addition problem
problem, solution = mathgen.addition()
#another way to generate an addition problem using genById()
problem, solution = mathgen.genById(0)
```
## List of Generators
| Id | Skill | Example problem | Example Solution | Function Name |
|------|-----------------------------------|--------------------|-------------------|--------------------------|
| 0 | Addition | 1+5= | 6 | addition |
| 1 | Subtraction | 9-4= | 5 | subtraction |
| 2 | Multiplication | 4*6= | 24 | multiplication |
| 3 | Division | 4/3= | 1.33333333 | division |
| 4 | Binary Complement 1s | 1010= | 0101 | binaryComplement1s |
| 5 | Modulo Division | 10%3= | 1 | moduloDivision |
| 6 | Square Root | sqrt(25)= | 5 | squareRootFunction |
| 7 | Power Rule Differentiation | 4x^3 | 12x^2 | powerRuleDifferentiation |
| 8 | Square | 4^2 | 16 | square |
| 9 | LCM (Least Common Multiple) | LCM of 14 and 9 = | 126 | lcm |
| 10 | GCD (Greatest Common Denominator) | GCD of 18 and 18 = | 18 | gcd |
| 11 | Basic Algebra | 9x + 7 = 10 | 1/3 | basicAlgebra |
| 12 | Logarithm | log3(3) | 1 | log |
| 13 | Easy Division | 270/15 = | 18 | intDivision |
| Id | Skill | Example problem | Example Solution | Function Name |
|------|-----------------------------------|--------------------|-----------------------|--------------------------|
| 0 | Addition | 1+5= | 6 | addition |
| 1 | Subtraction | 9-4= | 5 | subtraction |
| 2 | Multiplication | 4*6= | 24 | multiplication |
| 3 | Division | 4/3= | 1.33333333 | division |
| 4 | Binary Complement 1s | 1010= | 0101 | binaryComplement1s |
| 5 | Modulo Division | 10%3= | 1 | moduloDivision |
| 6 | Square Root | sqrt(25)= | 5 | squareRootFunction |
| 7 | Power Rule Differentiation | 4x^3 | 12x^2 | powerRuleDifferentiation |
| 8 | Square | 4^2 | 16 | square |
| 9 | LCM (Least Common Multiple) | LCM of 14 and 9 = | 126 | lcm |
| 10 | GCD (Greatest Common Denominator) | GCD of 18 and 18 = | 18 | gcd |
| 11 | Basic Algebra | 9x + 7 = 10 | 1/3 | basicAlgebra |
| 12 | Logarithm | log3(3) | 1 | log |
| 13 | Easy Division | 270/15 = | 18 | intDivision |
| 14 | Decimal to Binary | Binary of a= | b | decimalToBinary |
| 15 | Binary to Decimal | Decimal of a= | b | binaryToDecimal |
| 16 | Fraction Division | (a/b)/(c/d)= | x/y | fractionDivision |
| 17 | Int 2x2 Matrix Multiplication | k * [[a,b],[c,d]]= | [[k*a,k*b],[k*c,k*d]] | intMatrix22Multiplication|

2
dev-requirements.txt Normal file
View File

@@ -0,0 +1,2 @@
pytest
hypothesis

BIN
mathgenerator/__pycache__/__init__.cpython-37.pyc Normal file
View File

Binary file not shown.

BIN
mathgenerator/__pycache__/mathgen.cpython-37.pyc Normal file
View File

Binary file not shown.

546
mathgenerator/mathgen.py
View File

@@ -1,4 +1,6 @@
import random
import math
import fractions
genList = []
@@ -15,8 +17,8 @@ class Generator:
def __str__(self):
return str(self.id) + " " + self.title + " " + self.generalProb + " " + self.generalSol
def __call__(self):
return self.func()
def __call__(self, **kwargs):
return self.func(**kwargs)
# || Non-generator Functions
def genById(id):
@@ -206,6 +208,512 @@ def divideFractionsFunc(maxVal=10):
solution = x
return problem, solution
def multiplyIntToMatrix22(maxMatrixVal = 10, maxRes = 100):
a = random.randint(0, maxMatrixVal)
b = random.randint(0, maxMatrixVal)
c = random.randint(0, maxMatrixVal)
d = random.randint(0, maxMatrixVal)
constant = random.randint(0, int(maxRes/max(a,b,c,d)))
problem = f"{constant} * [[{a}, {b}], [{c}, {d}]] = "
solution = f"[[{a*constant},{b*constant}],[{c*constant},{d*constant}]]"
return problem, solution
def areaOfTriangleFunc(maxA=20, maxB=20, maxC=20):
a = random.randint(1, maxA)
b = random.randint(1, maxB)
c = random.randint(1, maxC)
s = (a+b+c)/2
area = (s*(s-a)*(s-b)*(s-c)) ** 0.5
problem = "Area of triangle with side lengths: "+ str(a) +" "+ str(b) +" "+ str(c) + " = "
solution = area
return problem, solution
def isTriangleValidFunc(maxSideLength = 50):
sideA = random.randint(1, maxSideLength)
sideB = random.randint(1, maxSideLength)
sideC = random.randint(1, maxSideLength)
sideSums = [sideA + sideB, sideB + sideC, sideC + sideA]
sides = [sideC, sideA, sideB]
exists = True & (sides[0] < sideSums[0]) & (sides[1] < sideSums[1]) & (sides[2] < sideSums[2])
problem = f"Does triangle with sides {sideA}, {sideB} and {sideC} exist?"
if exists:
solution = "Yes"
return problem, solution
solution = "No"
return problem, solution
def MidPointOfTwoPointFunc(maxValue=20):
x1=random.randint(-20,maxValue)
y1=random.randint(-20,maxValue)
x2=random.randint(-20,maxValue)
y2=random.randint(-20,maxValue)
problem=f"({x1},{y1}),({x2},{y2})="
solution=f"({(x1+x2)/2},{(y1+y2)/2})"
return problem,solution
def factoringFunc(range_x1 = 10, range_x2 = 10):
x1 = random.randint(-range_x1, range_x1)
x2 = random.randint(-range_x2, range_x2)
def intParser(z):
if (z == 0):
return ""
if (z > 0):
return "+" + str(z)
if (z < 0):
return "-" + str(abs(z))
b = intParser(x1 + x2)
c = intParser(x1 * x2)
if (b == "+1"):
b = "+"
if (b == ""):
problem = f"x^2{c}"
else:
problem = f"x^2{b}x{c}"
x1 = intParser(x1)
x2 = intParser(x2)
solution = f"(x{x1})(x{x2})"
return problem, solution
def thirdAngleOfTriangleFunc(maxAngle=89):
angle1 = random.randint(1, maxAngle)
angle2 = random.randint(1, maxAngle)
angle3 = 180 - (angle1 + angle2)
problem = f"Third angle of triangle with angles {angle1} and {angle2} = "
solution = angle3
return problem, solution
def systemOfEquationsFunc(range_x = 10, range_y = 10, coeff_mult_range=10):
# Generate solution point first
x = random.randint(-range_x, range_x)
y = random.randint(-range_y, range_y)
# Start from reduced echelon form (coeffs 1)
c1 = [1, 0, x]
c2 = [0, 1, y]
def randNonZero():
return random.choice([i for i in range(-coeff_mult_range, coeff_mult_range)
if i != 0])
# Add random (non-zero) multiple of equations (rows) to each other
c1_mult = randNonZero()
c2_mult = randNonZero()
new_c1 = [c1[i] + c1_mult * c2[i] for i in range(len(c1))]
new_c2 = [c2[i] + c2_mult * c1[i] for i in range(len(c2))]
# For extra randomness, now add random (non-zero) multiples of original rows
# to themselves
c1_mult = randNonZero()
c2_mult = randNonZero()
new_c1 = [new_c1[i] + c1_mult * c1[i] for i in range(len(c1))]
new_c2 = [new_c2[i] + c2_mult * c2[i] for i in range(len(c2))]
def coeffToFuncString(coeffs):
# lots of edge cases for perfect formatting!
x_sign = '-' if coeffs[0] < 0 else ''
# No redundant 1s
x_coeff = str(abs(coeffs[0])) if abs(coeffs[0]) != 1 else ''
# If x coeff is 0, dont include x
x_str = f'{x_sign}{x_coeff}x' if coeffs[0] != 0 else ''
# if x isn't included and y is positive, dont include operator
op = ' - ' if coeffs[1] < 0 else (' + ' if x_str != '' else '')
# No redundant 1s
y_coeff = abs(coeffs[1]) if abs(coeffs[1]) != 1 else ''
# Don't include if 0, unless x is also 0 (probably never happens)
y_str = f'{y_coeff}y' if coeffs[1] != 0 else ('' if x_str != '' else '0')
return f'{x_str}{op}{y_str} = {coeffs[2]}'
problem = f"{coeffToFuncString(new_c1)}, {coeffToFuncString(new_c2)}"
solution = f"x = {x}, y = {y}"
return problem, solution
# Add random (non-zero) multiple of equations to each other
def distanceTwoPointsFunc(maxValXY = 20, minValXY=-20):
point1X = random.randint(minValXY, maxValXY+1)
point1Y = random.randint(minValXY, maxValXY+1)
point2X = random.randint(minValXY, maxValXY+1)
point2Y = random.randint(minValXY, maxValXY+1)
distanceSq = (point1X - point2X) ** 2 + (point1Y - point2Y) ** 2
solution = f"sqrt({distanceSq})"
problem = f"Find the distance between ({point1X}, {point1Y}) and ({point2X}, {point2Y})"
return problem, solution
def pythagoreanTheoremFunc(maxLength = 20):
a = random.randint(1, maxLength)
b = random.randint(1, maxLength)
c = (a**2 + b**2)**0.5
problem = f"The hypotenuse of a right triangle given the other two lengths {a} and {b} = "
solution = f"{c:.0f}" if c.is_integer() else f"{c:.2f}"
return problem, solution
def linearEquationsFunc(n = 2, varRange = 20, coeffRange = 20):
if n > 10:
print("[!] n cannot be greater than 10")
return None, None
vars = ['x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g'][:n]
soln = [ random.randint(-varRange, varRange) for i in range(n) ]
problem = list()
solution = ", ".join(["{} = {}".format(vars[i], soln[i]) for i in range(n)])
for _ in range(n):
coeff = [ random.randint(-coeffRange, coeffRange) for i in range(n) ]
res = sum([ coeff[i] * soln[i] for i in range(n)])
prob = ["{}{}".format(coeff[i], vars[i]) if coeff[i] != 0 else "" for i in range(n)]
while "" in prob:
prob.remove("")
prob = " + ".join(prob) + " = " + str(res)
problem.append(prob)
problem = "\n".join(problem)
return problem, solution
def primeFactorsFunc(minVal=1, maxVal=200):
a = random.randint(minVal, maxVal)
n = a
i = 2
factors = []
while i * i <= n:
if n % i:
i += 1
else:
n //= i
factors.append(i)
if n > 1:
factors.append(n)
problem = f"Find prime factors of {a}"
solution = f"{factors}"
return problem, solution
def multiplyFractionsFunc(maxVal=10):
a = random.randint(1, maxVal)
b = random.randint(1, maxVal)
c = random.randint(1, maxVal)
d = random.randint(1, maxVal)
while (a == b):
b = random.randint(1, maxVal)
while (c == d):
d = random.randint(1, maxVal)
def calculate_gcd(x, y):
while(y):
x, y = y, x % y
return x
tmp_n = a * c
tmp_d = b * d
gcd = calculate_gcd(tmp_n, tmp_d)
x = f"{tmp_n//gcd}/{tmp_d//gcd}"
if (tmp_d == 1 or tmp_d == gcd):
x = f"{tmp_n//gcd}"
problem = f"({a}/{b})*({c}/{d})"
solution = x
return problem, solution
def regularPolygonAngleFunc(minVal = 3,maxVal = 20):
sideNum = random.randint(minVal, maxVal)
problem = f"Find the angle of a regular polygon with {sideNum} sides"
exteriorAngle = round((360/sideNum),2)
solution = 180 - exteriorAngle
return problem, solution
def combinationsFunc(maxlength=20):
def factorial(a):
d=1
for i in range(a):
a=(i+1)*d
d=a
return d
a= random.randint(10,maxlength)
b=random.randint(0,9)
solution= int(factorial(a)/(factorial(b)*factorial(a-b)))
problem= "Number of combinations from {} objects picked {} at a time ".format(a,b)
return problem, solution
def factorialFunc(maxInput = 6):
a = random.randint(0, maxInput)
n = a
problem = str(a) + "! = "
b = 1
if a == 1:
solution = str(b)
return problem, solution
else:
while n > 0:
b *= n
n = n - 1
solution = str(b)
return problem, solution
def surfaceAreaCube(maxSide = 20, unit = 'm'):
a = random.randint(1, maxSide)
problem = f"Surface area of cube with side = {a}{unit} is"
ans = 6 * a * a
solution = f"{ans} {unit}^2"
return problem, solution
def volumeCube(maxSide = 20, unit = 'm'):
a = random.randint(1, maxSide)
problem = f"Volume of cube with side = {a}{unit} is"
ans = a * a * a
solution = f"{ans} {unit}^3"
return problem, solution
def surfaceAreaCuboid(maxSide = 20, unit = 'm'):
a = random.randint(1, maxSide)
b = random.randint(1, maxSide)
c = random.randint(1, maxSide)
problem = f"Surface area of cuboid with sides = {a}{unit}, {b}{unit}, {c}{unit} is"
ans = 2 * (a*b + b*c + c*a)
solution = f"{ans} {unit}^2"
return problem, solution
def volumeCuboid(maxSide = 20, unit = 'm'):
a = random.randint(1, maxSide)
b = random.randint(1, maxSide)
c = random.randint(1, maxSide)
problem = f"Volume of cuboid with sides = {a}{unit}, {b}{unit}, {c}{unit} is"
ans = a * b * c
solution = f"{ans} {unit}^3"
return problem, solution
def surfaceAreaCylinder(maxRadius = 20, maxHeight = 50,unit = 'm'):
a = random.randint(1, maxHeight)
b = random.randint(1, maxRadius)
problem = f"Surface area of cylinder with height = {a}{unit} and radius = {b}{unit} is"
ans = int(2 * math.pi * a * b + 2 * math.pi * b * b)
solution = f"{ans} {unit}^2"
return problem, solution
def volumeCylinder(maxRadius = 20, maxHeight = 50, unit = 'm'):
a = random.randint(1, maxHeight)
b = random.randint(1, maxRadius)
problem = f"Volume of cylinder with height = {a}{unit} and radius = {b}{unit} is"
ans = int(math.pi * b * b * a)
solution = f"{ans} {unit}^3"
return problem, solution
def surfaceAreaCone(maxRadius = 20, maxHeight = 50,unit = 'm'):
a = random.randint(1, maxHeight)
b = random.randint(1, maxRadius)
slopingHeight = math.sqrt(a**2 + b**2)
problem = f"Surface area of cone with height = {a}{unit} and radius = {b}{unit} is"
ans = int(math.pi * b * slopingHeight + math.pi * b * b)
solution = f"{ans} {unit}^2"
return problem, solution
def volumeCone(maxRadius = 20, maxHeight = 50, unit = 'm'):
a = random.randint(1, maxHeight)
b = random.randint(1, maxRadius)
problem = f"Volume of cone with height = {a}{unit} and radius = {b}{unit} is"
ans = int(math.pi * b * b * a * (1/3))
solution = f"{ans} {unit}^3"
return problem, solution
def commonFactorsFunc(maxVal=100):
a = random.randint(1, maxVal)
b = random.randint(1, maxVal)
x, y = a, b
if (x < y):
min = x
else:
min = y
count = 0
arr = []
for i in range(1, min + 1):
if (x % i == 0):
if (y % i == 0):
count = count + 1
arr.append(i)
problem = f"Common Factors of {a} and {b} = "
solution = arr
return problem, solution
def intersectionOfTwoLinesFunc(
minM=-10, maxM=10, minB=-10, maxB=10, minDenominator=1, maxDenominator=6
):
def generateEquationString(m, b):
"""
Generates an equation given the slope and intercept.
It handles cases where m is fractional.
It also ensures that we don't have weird signs such as y = mx + -b.
"""
if m[1] == 1:
m = m[0]
else:
m = f"{m[0]}/{m[1]}"
base = f"y = {m}x"
if b > 0:
return f"{base} + {b}"
elif b < 0:
return f"{base} - {b * -1}"
else:
return base
def fractionToString(x):
"""
Converts the given fractions.Fraction into a string.
"""
if x.denominator == 1:
x = x.numerator
else:
x = f"{x.numerator}/{x.denominator}"
return x
m1 = (random.randint(minM, maxM), random.randint(minDenominator, maxDenominator))
m2 = (random.randint(minM, maxM), random.randint(minDenominator, maxDenominator))
b1 = random.randint(minB, maxB)
b2 = random.randint(minB, maxB)
equation1 = generateEquationString(m1, b1)
equation2 = generateEquationString(m2, b2)
problem = "Find the point of intersection of the two lines: "
problem += f"{equation1} and {equation2}"
m1 = fractions.Fraction(*m1)
m2 = fractions.Fraction(*m2)
# if m1 == m2 then the slopes are equal
# This can happen if both line are the same
# Or if they are parallel
# In either case there is no intersection
if m1 == m2:
solution = "No Solution"
else:
intersection_x = (b1 - b2) / (m2 - m1)
intersection_y = ((m2 * b1) - (m1 * b2)) / (m2 - m1)
solution = f"({fractionToString(intersection_x)}, {fractionToString(intersection_y)})"
return problem, solution
def permutationFunc(maxlength=20):
a = random.randint(10,maxlength)
b = random.randint(0,9)
solution= int(math.factorial(a)/(math.factorial(a-b)))
problem= "Number of Permutations from {} objects picked {} at a time = ".format(a,b)
return problem, solution
def vectorCrossFunc(minVal=-20, maxVal=20):
a = [random.randint(minVal, maxVal) for i in range(3)]
b = [random.randint(minVal, maxVal) for i in range(3)]
c = [a[1]*b[2] - a[2]*b[1],
a[2]*b[0] - a[0]*b[2],
a[0]*b[1] - a[1]*b[0]]
return str(a) + " X " + str(b) + " = ", str(c)
def compareFractionsFunc(maxVal=10):
a = random.randint(1, maxVal)
b = random.randint(1, maxVal)
c = random.randint(1, maxVal)
d = random.randint(1, maxVal)
while (a == b):
b = random.randint(1, maxVal)
while (c == d):
d = random.randint(1, maxVal)
first=a/b
second=c/d
if(first>second):
solution=">"
elif(first<second):
solution="<"
else:
solution="="
problem = f"Which symbol represents the comparison between {a}/{b} and {c}/{d}?"
return problem,solution
def simpleInterestFunc(maxPrinciple = 10000, maxRate = 10, maxTime = 10):
a = random.randint(1000, maxPrinciple)
b = random.randint(1, maxRate)
c = random.randint(1, maxTime)
d = (a*b*c)/100
problem = "Simple interest for a principle amount of " + str(a) +" dollars, " + str(b) + "% rate of interest and for a time period of " + str(c) + " years is = "
solution = round(d, 2)
return problem, solution
def matrixMultiplicationFunc(maxVal=100):
m= random.randint(2, 10)
n= random.randint(2, 10)
k= random.randint(2, 10)
#generate matrices a and b
a=[]
for r in range(m):
a.append([])
for c in range(n):
a[r].append(random.randint(-maxVal,maxVal))
b=[]
for r in range(n):
b.append([])
for c in range(k):
b[r].append(random.randint(-maxVal, maxVal))
res= []
a_string= matrixMultiplicationFuncHelper(a)
b_string= matrixMultiplicationFuncHelper(b)
for r in range(m):
res.append([])
for c in range(k):
temp= 0
for t in range(n):
temp+=a[r][t]*b[t][c]
res[r].append(temp)
problem= f"Multiply \n{a_string}\n and \n\n{b_string}" #consider using a, b instead of a_string, b_string if the problem doesn't look right
solution= matrixMultiplicationFuncHelper(res)
return problem, solution
def matrixMultiplicationFuncHelper(inp):
m= len(inp)
n= len(inp[0])
string= ""
for i in range(m):
for j in range(n):
string+=f"{inp[i][j]: 6d}"
string+=" "
string+="\n"
return string
def cubeRootFunc(minNo = 1, maxNo = 1000):
b = random.randint(minNo, maxNo)
a = b**(1/3)
problem = "cuberoot of " + str(b) + " upto 2 decimal places is:"
solution = str(round(a,2))
return problem, solution
def powerRuleIntegrationFunc(maxCoef = 10, maxExp = 10, maxTerms = 5):
numTerms = random.randint(1, maxTerms)
problem = ""
solution = ""
for i in range(numTerms):
if i > 0:
problem += " + "
solution += " + "
coefficient = random.randint(1, maxCoef)
exponent = random.randint(1, maxExp)
problem += str(coefficient) + "x^" + str(exponent)
solution += "("+str(coefficient) +"/"+str(exponent) +")x^" + str(exponent +1)
solution = solution + " + c"
return problem, solution
def fourthAngleOfQuadriFunc(maxAngle = 180):
angle1 = random.randint(1, maxAngle)
angle2 = random.randint(1, 240-angle1)
angle3 = random.randint(1, 340-(angle1 + angle2))
sum_ = angle1 + angle2 + angle3
angle4 = 360 - sum_
problem = f"Fourth angle of quadrilateral with angles {angle1} , {angle2}, {angle3} ="
solution = angle4
return problem, solution
# || Class Instances
#Format is:
@@ -227,3 +735,37 @@ intDivision = Generator("Easy Division", 13,"a/b=","c",divisionToIntFunc)
decimalToBinary = Generator("Decimal to Binary",14,"Binary of a=","b",DecimalToBinaryFunc)
binaryToDecimal = Generator("Binary to Decimal",15,"Decimal of a=","b",BinaryToDecimalFunc)
fractionDivision = Generator("Fraction Division", 16, "(a/b)/(c/d)=", "x/y", divideFractionsFunc)
intMatrix22Multiplication = Generator("Integer Multiplication with 2x2 Matrix", 17, "k * [[a,b],[c,d]]=", "[[k*a,k*b],[k*c,k*d]]", multiplyIntToMatrix22)
areaOfTriangle = Generator("Area of Triangle", 18, "Area of Triangle with side lengths a, b, c = ", "area", areaOfTriangleFunc)
doesTriangleExist = Generator("Triangle exists check", 19, "Does triangle with sides a, b and c exist?","Yes/No", isTriangleValidFunc)
midPointOfTwoPoint=Generator("Midpoint of the two point", 20,"((X1,Y1),(X2,Y2))=","((X1+X2)/2,(Y1+Y2)/2)",MidPointOfTwoPointFunc)
factoring = Generator("Factoring Quadratic", 21, "x^2+(x1+x2)+x1*x2", "(x-x1)(x-x2)", factoringFunc)
thirdAngleOfTriangle = Generator("Third Angle of Triangle", 22, "Third Angle of the triangle = ", "angle3", thirdAngleOfTriangleFunc)
systemOfEquations = Generator("Solve a System of Equations in R^2", 23, "2x + 5y = 13, -3x - 3y = -6", "x = -1, y = 3",
systemOfEquationsFunc)
distance2Point = Generator("Distance between 2 points", 24, "Find the distance between (x1,y1) and (x2,y2)","sqrt(distanceSquared)", distanceTwoPointsFunc)
pythagoreanTheorem = Generator("Pythagorean Theorem", 25, "The hypotenuse of a right triangle given the other two lengths a and b = ", "hypotenuse", pythagoreanTheoremFunc)
linearEquations = Generator("Linear Equations", 26, "2x+5y=20 & 3x+6y=12", "x=-20 & y=12", linearEquationsFunc) #This has multiple variables whereas #23 has only x and y
primeFactors = Generator("Prime Factorisation", 27, "Prime Factors of a =", "[b, c, d, ...]", primeFactorsFunc)
fractionMultiplication = Generator("Fraction Multiplication", 28, "(a/b)*(c/d)=", "x/y", multiplyFractionsFunc)
angleRegularPolygon = Generator("Angle of a Regular Polygon",29,"Find the angle of a regular polygon with 6 sides","120",regularPolygonAngleFunc)
combinations = Generator("Combinations of Objects",30, "Combinations available for picking 4 objects at a time from 6 distinct objects ="," 15", combinationsFunc)
factorial = Generator("Factorial", 31, "a! = ", "b", factorialFunc)
surfaceAreaCubeGen = Generator("Surface Area of Cube", 32, "Surface area of cube with side a units is","b units^2", surfaceAreaCube)
surfaceAreaCuboidGen = Generator("Surface Area of Cuboid", 33, "Surface area of cuboid with sides = a units, b units, c units is","d units^2", surfaceAreaCuboid)
surfaceAreaCylinderGen = Generator("Surface Area of Cylinder", 34, "Surface area of cylinder with height = a units and radius = b units is","c units^2", surfaceAreaCylinder)
volumeCubeGen = Generator("Volum of Cube", 35, "Volume of cube with side a units is","b units^3", volumeCube)
volumeCuboidGen = Generator("Volume of Cuboid", 36, "Volume of cuboid with sides = a units, b units, c units is","d units^3", volumeCuboid)
volumeCylinderGen = Generator("Volume of cylinder", 37, "Volume of cylinder with height = a units and radius = b units is","c units^3", volumeCylinder)
surfaceAreaConeGen = Generator("Surface Area of cone", 38, "Surface area of cone with height = a units and radius = b units is","c units^2", surfaceAreaCone)
volumeConeGen = Generator("Volume of cone", 39, "Volume of cone with height = a units and radius = b units is","c units^3", volumeCone)
commonFactors = Generator("Common Factors", 40, "Common Factors of {a} and {b} = ","[c, d, ...]",commonFactorsFunc)
intersectionOfTwoLines = Generator("Intersection of Two Lines", 41, "Find the point of intersection of the two lines: y = m1*x + b1 and y = m2*x + b2", "(x, y)", intersectionOfTwoLinesFunc)
permutations= Generator("Permutations",42, "Total permutations of 4 objects at a time from 10 objects is","5040", permutationFunc)
vectorCross = Generator("Cross Product of 2 Vectors", 43, "a X b = ", "c", vectorCrossFunc)
compareFractions=Generator("Compare Fractions",44,"Which symbol represents the comparison between a/b and c/d?",">/</=",compareFractionsFunc)
simpleInterest = Generator("Simple Interest", 45, "Simple interest for a principle amount of a dollars, b% rate of interest and for a time period of c years is = ", "d dollars", simpleInterestFunc)
matrixMultiplication = Generator("Multiplication of two matrices", 46, "Multiply two matrices A and B", "C", matrixMultiplicationFunc)
CubeRoot = Generator("Cube Root",47,"Cuberoot of a upto 2 decimal places is","b",cubeRootFunc)
powerRuleIntegration = Generator("Power Rule Integration", 48, "nx^m=", "(n/m)x^(m+1)", powerRuleIntegrationFunc)
fourthAngleOfQuadrilateral = Generator("Fourth Angle of Quadrilateral",49,"Fourth angle of Quadrilateral with angles a,b,c =","angle4",fourthAngleOfQuadriFunc)

2
setup.py
View File

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
setup(
name='mathgenerator',
version='1.1.0',
version='1.1.1',
description='An open source solution for generating math problems',
url='https://github.com/todarith/mathgenerator',
author='Luke Weiler',

46
tests/test_mathgen.py Normal file
View File

@@ -0,0 +1,46 @@
from math import sqrt
from mathgenerator.mathgen import *
from hypothesis import strategies as st, given, assume
@given(maxSum=st.integers(min_value=1), maxAddend=st.integers(min_value=1))
def test_additionFunc(maxSum, maxAddend):
assume(maxSum > maxAddend)
problem, solution = additionFunc(maxSum, maxAddend)
assert eval(problem[:-1]) == int(solution)
@given(maxMinuend=st.integers(min_value=1), maxDiff=st.integers(min_value=1))
def test_subtractionFunc(maxMinuend, maxDiff):
assume(maxMinuend > maxDiff)
problem, solution = subtractionFunc(maxMinuend, maxDiff)
assert eval(problem[:-1]) == int(solution)
@given(maxRes=st.integers(min_value=1), maxMulti=st.integers(min_value=1))
def test_multiplicationFunc(maxRes, maxMulti):
assume(maxRes > maxMulti)
problem, solution = multiplicationFunc(maxRes, maxMulti)
assert eval(problem[:-1]) == int(solution)
@given(maxRes=st.integers(min_value=1), maxDivid=st.integers(min_value=1))
def test_divisionFunc(maxRes, maxDivid):
assume(maxRes > maxDivid)
problem, solution = divisionFunc(maxRes, maxDivid)
assert eval(problem[:-1]) == float(solution)
@given(maxRes=st.integers(min_value=1), maxModulo=st.integers(min_value=1))
def test_moduloFunc(maxRes, maxModulo):
assume(maxRes > maxModulo)
problem, solution = moduloFunc(maxRes, maxModulo)
assert eval(problem[:-1]) == int(solution)
@given(minNo=st.integers(min_value=1), maxNo=st.integers(min_value=1, max_value=2 ** 50))
def test_squareRootFunc(minNo, maxNo):
assume(maxNo > minNo)
problem, solution = squareRootFunc(minNo, maxNo)
assert eval(problem[:-1]) == float(solution)