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 #1 from Todarith/master

Browse Source 
Pull Request
This commit is contained in:
SAKSHI KULSHRESHTHA
2020-10-18 21:37:28 +05:30
committed by GitHub
parent 72b690aa80 4331db74d0
commit ffebaeb636
13 changed files with 521 additions and 324 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
.github/ISSUE_TEMPLATE/new-generator-idea.md vendored Normal file
View File

@@ -0,0 +1,16 @@
---
name: New Generator Idea
about: Use this template if you have an idea for a new generator.
title: ''
labels: New generator, hacktoberfest
assignees: ''
---
**Example Problem:**
**Example Solution:**
**Further explanation:**
**Would you like to be assigned to this:**

10
.github/ISSUE_TEMPLATE/other-issue.md vendored Normal file
View File

@@ -0,0 +1,10 @@
---
name: Other Issue
about: If your issue lies outside of the other templates
title: ''
labels: ''
assignees: ''
---

12
.github/ISSUE_TEMPLATE/request-changes-to-a-generator.md vendored Normal file
View File

@@ -0,0 +1,12 @@
---
name: Request changes to a generator
about: If you find a faulty generator that needs a fix, use this template.
title: ''
labels: bug, hacktoberfest
assignees: ''
---
**Name or Id of generator:**
**Issue:**

44
.github/workflows/tests.yaml vendored
View File

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

9
Makefile
View File

@@ -1,2 +1,7 @@
test: FLAKE_FLAGS = --ignore=E501,F401,F403,F405
python -m pytest --verbose -s tests
lint:
python -m flake8 $(FLAKE_FLAGS)
test:
python -m pytest --verbose -s tests

137
README.md
View File

@@ -30,53 +30,90 @@ problem, solution = mathgen.genById(0)
| Id | Skill | Example problem | Example Solution | Function Name | | Id | Skill | Example problem | Example Solution | Function Name |
|------|-----------------------------------|--------------------|-----------------------|--------------------------| |------|-----------------------------------|--------------------|-----------------------|--------------------------|
| 0 | Addition | 29+33= | 62 | addition | | 0 | Addition | 42+2= | 44 | addition |
| 1 | Subtraction | 62-7= | 55 | subtraction | | 1 | Subtraction | 32-26= | 6 | subtraction |
| 2 | Multiplication | 93*1= | 93 | multiplication | | 2 | Multiplication | 77*1= | 77 | multiplication |
| 3 | Division | 59/47= | 1.2553191489361701 | division | | 3 | Division | 66/9= | 7.333333333333333 | division |
| 4 | Binary Complement 1s | 001110000 | 110001111 | binaryComplement1s | | 4 | Binary Complement 1s | 1010000 | 0101111 | binaryComplement1s |
| 5 | Modulo Division | 89%34= | 21 | moduloDivision | | 5 | Modulo Division | 61%35= | 26 | moduloDivision |
| 6 | Square Root | sqrt(16)= | 4 | squareRoot | | 6 | Square Root | sqrt(1)= | 1 | squareRoot |
| 7 | Power Rule Differentiation | 4x^3 | 12x^2 | powerRuleDifferentiation | | 7 | Power Rule Differentiation | 5x^5 | 25x^4 | powerRuleDifferentiation |
| 8 | Square | 12^2= | 144 | square | | 8 | Square | 20^2= | 400 | square |
| 9 | LCM (Least Common Multiple) | LCM of 10 and 1 = | 10 | lcm | | 9 | LCM (Least Common Multiple) | LCM of 19 and 5 = | 95 | lcm |
| 10 | GCD (Greatest Common Denominator) | GCD of 12 and 5 = | 1 | gcd | | 10 | GCD (Greatest Common Denominator) | GCD of 10 and 11 = | 1 | gcd |
| 11 | Basic Algebra | 8x + 7 = 10 | 3/8 | basicAlgebra | | 11 | Basic Algebra | 3x + 7 = 8 | 1/3 | basicAlgebra |
| 12 | Logarithm | log3(729) | 6 | log | | 12 | Logarithm | log2(128) | 7 | log |
| 13 | Easy Division | 378/21 = | 18 | intDivision | | 13 | Easy Division | 306/18 = | 17 | intDivision |
| 14 | Decimal to Binary | Binary of 4= | 100 | decimalToBinary | | 14 | Decimal to Binary | Binary of 28= | 11100 | decimalToBinary |
| 15 | Binary to Decimal | 10011 | 19 | binaryToDecimal | | 15 | Binary to Decimal | 10001101 | 141 | binaryToDecimal |
| 16 | Fraction Division | (1/2)/(4/3) | 3/8 | fractionDivision | | 16 | Fraction Division | (4/1)/(6/3) | 2 | fractionDivision |
| 17 | Integer Multiplication with 2x2 Matrix | 2 * [[0, 7], [7, 7]] = | [[0,14],[14,14]] | intMatrix22Multiplication | | 17 | Integer Multiplication with 2x2 Matrix | 5 * [[10, 3], [0, 1]] = | [[50,15],[0,5]] | intMatrix22Multiplication |
| 18 | Area of Triangle | Area of triangle with side lengths: 9 14 15 = | 61.644140029689765 | areaOfTriangle | | 18 | Area of Triangle | Area of triangle with side lengths: 13 2 14 = | 11.659223816361019 | areaOfTriangle |
| 19 | Triangle exists check | Does triangle with sides 33, 6 and 43 exist? | No | doesTriangleExist | | 19 | Triangle exists check | Does triangle with sides 3, 4 and 25 exist? | No | doesTriangleExist |
| 20 | Midpoint of the two point | (-15,-10),(-5,2)= | (-10.0,-4.0) | midPointOfTwoPoint | | 20 | Midpoint of the two point | (4,-11),(17,-5)= | (10.5,-8.0) | midPointOfTwoPoint |
| 21 | Factoring Quadratic | x^2-17x+72 | (x-9)(x-8) | factoring | | 21 | Factoring Quadratic | x^2-12x+35 | (x-7)(x-5) | factoring |
| 22 | Third Angle of Triangle | Third angle of triangle with angles 4 and 31 = | 145 | thirdAngleOfTriangle | | 22 | Third Angle of Triangle | Third angle of triangle with angles 20 and 62 = | 98 | thirdAngleOfTriangle |
| 23 | Solve a System of Equations in R^2 | 4x - 8y = 48, 3x - 8y = 40 | x = 8, y = -2 | systemOfEquations | | 23 | Solve a System of Equations in R^2 | 5x - 7y = -84, 4x + 5y = 7 | x = -7, y = 7 | systemOfEquations |
| 24 | Distance between 2 points | Find the distance between (-9, -20) and (18, -19) | sqrt(730) | distance2Point | | 24 | Distance between 2 points | Find the distance between (5, -18) and (1, 19) | sqrt(1385) | distance2Point |
| 25 | Pythagorean Theorem | The hypotenuse of a right triangle given the other two lengths 18 and 13 = | 22.20 | pythagoreanTheorem | | 25 | Pythagorean Theorem | The hypotenuse of a right triangle given the other two lengths 15 and 5 = | 15.81 | pythagoreanTheorem |
| 26 | Linear Equations | -11x + -16y = -302 , 1x + 20y = 250 | x = 10, y = 12 | linearEquations | | 26 | Linear Equations | -6x + -17y = -220
| 27 | Prime Factorisation | Find prime factors of 55 | [5, 11] | primeFactors | -13x + -19y = -120 | x = -20, y = 20 | linearEquations |
| 28 | Fraction Multiplication | (4/9)*(8/10) | 16/45 | fractionMultiplication | | 27 | Prime Factorisation | Find prime factors of 62 | [2, 31] | primeFactors |
| 29 | Angle of a Regular Polygon | Find the angle of a regular polygon with 15 sides | 156.0 | angleRegularPolygon | | 28 | Fraction Multiplication | (8/4)*(1/2) | 1 | fractionMultiplication |
| 30 | Combinations of Objects | Number of combinations from 13 objects picked 1 at a time | 13 | combinations | | 29 | Angle of a Regular Polygon | Find the angle of a regular polygon with 19 sides | 161.05 | angleRegularPolygon |
| 31 | Factorial | 2! = | 2 | factorial | | 30 | Combinations of Objects | Number of combinations from 12 objects picked 1 at a time | 12 | combinations |
| 32 | Surface Area of Cube | Surface area of cube with side = 13m is | 1014 m^2 | surfaceAreaCubeGen | | 31 | Factorial | 0! = | 1 | factorial |
| 33 | Surface Area of Cuboid | Surface area of cuboid with sides = 5m, 3m, 7m is | 142 m^2 | surfaceAreaCuboidGen | | 32 | Surface Area of Cube | Surface area of cube with side = 8m is | 384 m^2 | surfaceAreaCubeGen |
| 34 | Surface Area of Cylinder | Surface area of cylinder with height = 15m and radius = 7m is | 967 m^2 | surfaceAreaCylinderGen | | 33 | Surface Area of Cuboid | Surface area of cuboid with sides = 18m, 17m, 1m is | 682 m^2 | surfaceAreaCuboidGen |
| 35 | Volum of Cube | Volume of cube with side = 11m is | 1331 m^3 | volumeCubeGen | | 34 | Surface Area of Cylinder | Surface area of cylinder with height = 31m and radius = 1m is | 201 m^2 | surfaceAreaCylinderGen |
| 36 | Volume of Cuboid | Volume of cuboid with sides = 6m, 1m, 10m is | 60 m^3 | volumeCuboidGen | | 35 | Volum of Cube | Volume of cube with side = 9m is | 729 m^3 | volumeCubeGen |
| 37 | Volume of cylinder | Volume of cylinder with height = 26m and radius = 15m is | 18378 m^3 | volumeCylinderGen | | 36 | Volume of Cuboid | Volume of cuboid with sides = 20m, 1m, 10m is | 200 m^3 | volumeCuboidGen |
| 38 | Surface Area of cone | Surface area of cone with height = 46m and radius = 14m is | 2730 m^2 | surfaceAreaConeGen | | 37 | Volume of cylinder | Volume of cylinder with height = 7m and radius = 7m is | 1077 m^3 | volumeCylinderGen |
| 39 | Volume of cone | Volume of cone with height = 7m and radius = 11m is | 886 m^3 | volumeConeGen | | 38 | Surface Area of cone | Surface area of cone with height = 47m and radius = 13m is | 2522 m^2 | surfaceAreaConeGen |
| 40 | Common Factors | Common Factors of 91 and 51 = | [1] | commonFactors | | 39 | Volume of cone | Volume of cone with height = 4m and radius = 4m is | 67 m^3 | volumeConeGen |
| 41 | Intersection of Two Lines | Find the point of intersection of the two lines: y = 6/4x + 5 and y = -7/2x + 3 | (-2/5, 22/5) | intersectionOfTwoLines | | 40 | Common Factors | Common Factors of 20 and 90 = | [1, 2, 5, 10] | commonFactors |
| 42 | Permutations | Number of Permutations from 13 objects picked 4 at a time = | 17160 | permutations | | 41 | Intersection of Two Lines | Find the point of intersection of the two lines: y = -3/6x + 1 and y = 0/2x + 6 | (-10, 6) | intersectionOfTwoLines |
| 43 | Cross Product of 2 Vectors | [-14, 13, 20] X [-5, -18, 19] = | [607, 166, 317] | vectorCross | | 42 | Permutations | Number of Permutations from 11 objects picked 2 at a time = | 110 | permutations |
| 44 | Compare Fractions | Which symbol represents the comparison between 8/3 and 6/7? | > | compareFractions | | 43 | Cross Product of 2 Vectors | [-19, -3, 2] X [-15, -12, 7] = | [3, 103, 183] | vectorCross |
| 45 | Simple Interest | Simple interest for a principle amount of 6128 dollars, 5% rate of interest and for a time period of 5 years is = | 1532.0 | simpleInterest | | 44 | Compare Fractions | Which symbol represents the comparison between 8/6 and 3/1? | < | compareFractions |
| 46 | Multiplication of two matrices | Multiply [[-20, -14, -88, -62, 39, 94, 21, 75, 26], [89, -67, -80, -60, 32, -23, -79, 11, -69], [13, -75, -66, 3, 67, -79, -49, 6, 36], [-44, -84, 68, -27, -86, -95, -71, -77, -62], [45, 58, 89, 82, 30, -83, -23, 51, 95], [11, 46, 100, -15, 60, -34, 85, 50, -44], [93, -100, -62, 63, -73, -64, 90, -15, 23], [-8, 91, -22, 53, -42, 25, 32, -26, 31], [-60, 90, 75, -42, 19, 33, -30, 74, 13]] and [[-80, 54, -39, 37, -99], [31, -28, -31, 64, 73], [-21, -34, -28, -21, -76], [-94, 55, 66, 0, 17], [-28, 25, -65, -74, 100], [76, 74, -96, -98, -5], [-90, -70, -66, -71, -35], [65, 49, -100, 72, -23], [-95, -97, -31, -84, -86]] | [[15409, 6508, -21665, -10161, 5326], [9859, 17962, 3267, 12768, 3119], [-8761, 1272, 8611, 738, 3881], [4489, -5790, 29652, 11947, -5940], [-22167, -8208, -1142, 6747, -10714], [-4628, -5167, -15527, 1404, 243], [-29240, -2432, 11103, 615, -22487], [-5498, -5038, 1462, -100, 2495], [18214, -3238, -15548, 3691, 6061]] | matrixMultiplication | | 45 | Simple Interest | Simple interest for a principle amount of 9862 dollars, 4% rate of interest and for a time period of 1 years is = | 394.48 | simpleInterest |
| 47 | Cube Root | cuberoot of 711 upto 2 decimal places is: | 8.93 | CubeRoot | | 46 | Multiplication of two matrices | Multiply
| 48 | Power Rule Integration | 3x^1 | (3/1)x^2 + c | powerRuleIntegration | -50 36 7 -26 -2 63
| 49 | Fourth Angle of Quadrilateral | Fourth angle of quadrilateral with angles 94 , 101, 102 = | 63 | fourthAngleOfQuadrilateral | 88 -37 60 -19 61 -56
48 -5 69 -87 -64 -92
-84 -50 -79 -19 86 -13
0 28 12 -14 73 -49
94 -90 2 26 -38 19
2 -11 79 -77 98 -77
-87 70 72 -32 64 -99
and
34 32 -6 -32 46 -23 78 -81 -18
-17 24 49 -62 -50 77 38 -98 -64
-23 -78 43 5 -83 -5 4 -92 -16
46 -47 -92 52 -25 -37 44 51 -7
20 26 70 37 96 -73 49 84 42
-72 -15 -80 -24 58 -47 -41 45 -69 | -8245 -1057 -423 -3535 -569 2034 -6329 1219 -5765
6619 567 10737 2391 4001 -6291 10147 -7387 6383
1472 -161 13318 -5565 -12574 10381 638 -23699 2621
1593 5598 3465 7899 13170 -6487 -4857 24642 10618
3592 3027 12206 1473 2120 -412 6082 -635 4561
3748 -1803 -11460 2072 5462 -8183 2423 11 947
2400 960 22950 2483 952 -1974 4625 -5512 9372
1132 -2067 22392 1884 -12276 8196 1949 -7148 5677 | matrixMultiplication |
| 47 | Cube Root | cuberoot of 771 upto 2 decimal places is: | 9.17 | CubeRoot |
| 48 | Power Rule Integration | 1x^3 + 8x^8 + 10x^10 | (1/3)x^4 + (8/8)x^9 + (10/10)x^11 + c | powerRuleIntegration |
| 49 | Fourth Angle of Quadrilateral | Fourth angle of quadrilateral with angles 52 , 84, 154 = | 70 | fourthAngleOfQuadrilateral |
| 50 | Quadratic Equation | Zeros of the Quadratic Equation 51x^2+152x+80=0 | [-0.68, -2.3] | quadraticEquationSolve |
| 51 | HCF (Highest Common Factor) | HCF of 11 and 7 = | 1 | hcf |
| 52 | Probability of a certain sum appearing on faces of dice | If 2 dice are rolled at the same time, the probability of getting a sum of 11 = | 2/36 | diceSumProbability |
| 53 | Exponentiation | 9^9 = | 387420489 | exponentiation |
| 54 | Confidence interval For sample S | The confidence interval for sample [291, 254, 274, 207, 253, 289, 268, 280, 225, 240, 278, 270, 247, 252, 211, 212, 295, 241, 290, 206, 222, 263, 264, 228, 229, 256, 209, 292] with 99% confidence is | (265.560249263099, 237.72546502261523) | confidenceInterval |
| 55 | Comparing surds | Fill in the blanks 16^(1/7) _ 67^(1/6) | < | surdsComparison |
| 56 | Fibonacci Series | The Fibonacci Series of the first 11 numbers is ? | [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55] | fibonacciSeries |
| 57 | Trigonometric Values | What is cos(60)? | 1/2 | basicTrigonometry |
| 58 | Sum of Angles of Polygon | Sum of angles of polygon with 5 sides = | 540 | sumOfAnglesOfPolygon |
| 59 | Mean,Standard Deviation,Variance | Find the mean,standard deviation and variance for the data[38, 29, 43, 25, 7, 10, 13, 14, 43, 44, 30, 42, 48, 48, 42] | The Mean is 31.733333333333334 , Standard Deviation is 199.26222222222222, Variance is 14.116027140177303 | dataSummary |
| 59 | Surface Area of Sphere | Surface area of Sphere with radius = 13m is | 2123.7166338267 m^2 | surfaceAreaSphereGen |
| 60 | Volume of Sphere | Volume of sphere with radius 84 m = | 2482712.7095377133 m^3 | volumeSphere |

5
dev-requirements.txt
View File

@@ -1,2 +1,3 @@
pytest pytest
hypothesis hypothesis
flake8

25
makeReadme.py Normal file
View File

@@ -0,0 +1,25 @@
#To use, paste at bottom of mathgen.py code, change line variable and remove all table rows in README.md except for the top 2 and run mathgen.py
wList = getGenList()
allRows = []
f=open('mathgen.py')
lines=f.readlines()
line = 720 #This has to be changed depending on which line the first generator appears on
for item in wList:
myGen = item[2]
prob, sol = myGen()
prob = str(prob).rstrip("\n")
sol = str(sol).rstrip("\n")
instName = lines[line]
def_name = instName[:instName.find('=')].strip()
row = [myGen.id, myGen.title, prob, sol, def_name]
line+=1
allRows.append(row)
g=open('../README.md', "a")
for row in allRows:
tableLine = "| " + str(row[0]) + " | " + str(row[1]) + " | " + str(row[2]) + " | " + str(row[3]) + " | " + str(row[4]) + " |\n"
g.write(tableLine)
g.close()
print("New README.md table generated")

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

Binary file not shown.

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

Binary file not shown.

561
mathgenerator/mathgen.py
View File

@@ -4,6 +4,7 @@ import fractions
genList = [] genList = []
# || Generator class # || Generator class
class Generator: class Generator:
def __init__(self, title, id, generalProb, generalSol, func): def __init__(self, title, id, generalProb, generalSol, func):
@@ -20,76 +21,86 @@ class Generator:
def __call__(self, **kwargs): def __call__(self, **kwargs):
return self.func(**kwargs) return self.func(**kwargs)
# || Non-generator Functions # || Non-generator Functions
def genById(id): def genById(id):
generator = genList[id][2] generator = genList[id][2]
return(generator()) return(generator())
def getGenList(): def getGenList():
return(genList) return(genList)
# || Generator Functions # || Generator Functions
def additionFunc(maxSum = 99, maxAddend = 50):
def additionFunc(maxSum=99, maxAddend=50):
a = random.randint(0, maxAddend) a = random.randint(0, maxAddend)
b = random.randint(0, min((maxSum-a), maxAddend)) #The highest value of b will be no higher than the maxsum minus the first number and no higher than the maxAddend as well b = random.randint(0, min((maxSum - a), maxAddend)) # The highest value of b will be no higher than the maxsum minus the first number and no higher than the maxAddend as well
c = a+b c = a + b
problem = str(a) + "+" + str(b) + "=" problem = str(a) + "+" + str(b) + "="
solution = str(c) solution = str(c)
return problem, solution return problem, solution
def subtractionFunc(maxMinuend = 99, maxDiff = 99):
def subtractionFunc(maxMinuend=99, maxDiff=99):
a = random.randint(0, maxMinuend) a = random.randint(0, maxMinuend)
b = random.randint(max(0, (a-maxDiff)), a) b = random.randint(max(0, (a - maxDiff)), a)
c = a-b c = a - b
problem = str(a) + "-" + str(b) + "=" problem = str(a) + "-" + str(b) + "="
solution = str(c) solution = str(c)
return problem, solution return problem, solution
def multiplicationFunc(maxRes = 99, maxMulti = 99):
def multiplicationFunc(maxRes=99, maxMulti=99):
a = random.randint(0, maxMulti) a = random.randint(0, maxMulti)
b = random.randint(0, min(int(maxMulti/a), maxRes)) b = random.randint(0, min(int(maxMulti / a), maxRes))
c = a*b c = a * b
problem = str(a) + "*" + str(b) + "=" problem = str(a) + "*" + str(b) + "="
solution = str(c) solution = str(c)
return problem, solution return problem, solution
def divisionFunc(maxRes = 99, maxDivid = 99):
def divisionFunc(maxRes=99, maxDivid=99):
a = random.randint(0, maxDivid) a = random.randint(0, maxDivid)
b = random.randint(0, min(maxRes, maxDivid)) b = random.randint(0, min(maxRes, maxDivid))
c = a/b c = a / b
problem = str(a) + "/" + str(b) + "=" problem = str(a) + "/" + str(b) + "="
solution = str(c) solution = str(c)
return problem, solution return problem, solution
def binaryComplement1sFunc(maxDigits = 10):
def binaryComplement1sFunc(maxDigits=10):
question = '' question = ''
answer = '' answer = ''
for i in range(random.randint(1,maxDigits)): for i in range(random.randint(1, maxDigits)):
temp = str(random.randint(0, 1)) temp = str(random.randint(0, 1))
question += temp question += temp
answer += "0" if temp == "1" else "1" answer += "0" if temp == "1" else "1"
problem = question problem = question+"="
solution = answer solution = answer
return problem, solution return problem, solution
def moduloFunc(maxRes = 99, maxModulo= 99):
def moduloFunc(maxRes=99, maxModulo=99):
a = random.randint(0, maxModulo) a = random.randint(0, maxModulo)
b = random.randint(0, min(maxRes, maxModulo)) b = random.randint(0, min(maxRes, maxModulo))
c = a%b c = a % b
problem = str(a) + "%" + str(b) + "=" problem = str(a) + "%" + str(b) + "="
solution = str(c) solution = str(c)
return problem, solution return problem, solution
def squareRootFunc(minNo = 1, maxNo = 12):
def squareRootFunc(minNo=1, maxNo=12):
b = random.randint(minNo, maxNo) b = random.randint(minNo, maxNo)
a = b*b a = b * b
problem = "sqrt(" + str(a) + ")=" problem = "sqrt(" + str(a) + ")="
solution = str(b) solution = str(b)
return problem, solution return problem, solution
def powerRuleDifferentiationFunc(maxCoef = 10, maxExp = 10, maxTerms = 5):
def powerRuleDifferentiationFunc(maxCoef=10, maxExp=10, maxTerms=5):
numTerms = random.randint(1, maxTerms) numTerms = random.randint(1, maxTerms)
problem = "" problem = ""
solution = "" solution = ""
@@ -103,23 +114,26 @@ def powerRuleDifferentiationFunc(maxCoef = 10, maxExp = 10, maxTerms = 5):
solution += str(coefficient * exponent) + "x^" + str(exponent - 1) solution += str(coefficient * exponent) + "x^" + str(exponent - 1)
return problem, solution return problem, solution
def squareFunc(maxSquareNum = 20):
def squareFunc(maxSquareNum=20):
a = random.randint(1, maxSquareNum) a = random.randint(1, maxSquareNum)
b = a * a b = a * a
problem = str(a) + "^2" + "=" problem = str(a) + "^2" + "="
solution = str(b) solution = str(b)
return problem, solution return problem, solution
def gcdFunc(maxVal=20): def gcdFunc(maxVal=20):
a = random.randint(1, maxVal) a = random.randint(1, maxVal)
b = random.randint(1, maxVal) b = random.randint(1, maxVal)
x, y = a, b x, y = a, b
while(y): while(y):
x, y = y, x % y x, y = y, x % y
problem = f"GCD of {a} and {b} = " problem = f"GCD of {a} and {b} = "
solution = str(x) solution = str(x)
return problem, solution return problem, solution
def lcmFunc(maxVal=20): def lcmFunc(maxVal=20):
a = random.randint(1, maxVal) a = random.randint(1, maxVal)
b = random.randint(1, maxVal) b = random.randint(1, maxVal)
@@ -128,15 +142,17 @@ def lcmFunc(maxVal=20):
while(y): while(y):
x, y = y, x % y x, y = y, x % y
d = c // x d = c // x
problem = f"LCM of {a} and {b} = " problem = f"LCM of {a} and {b} ="
solution = str(d) solution = str(d)
return problem, solution return problem, solution
def basicAlgebraFunc(maxVariable = 10):
def basicAlgebraFunc(maxVariable=10):
a = random.randint(1, maxVariable) a = random.randint(1, maxVariable)
b = random.randint(1, maxVariable) b = random.randint(1, maxVariable)
c = random.randint(b, maxVariable) c = random.randint(b, maxVariable)
# calculate gcd # calculate gcd
def calculate_gcd(x, y): def calculate_gcd(x, y):
while(y): while(y):
x, y = y, x % y x, y = y, x % y
@@ -145,44 +161,49 @@ def basicAlgebraFunc(maxVariable = 10):
x = f"{(c - b)//i}/{a//i}" x = f"{(c - b)//i}/{a//i}"
if (c - b == 0): if (c - b == 0):
x = "0" x = "0"
elif a == 1 or a == i : elif a == 1 or a == i:
x = f"{c - b}" x = f"{c - b}"
problem = f"{a}x + {b} = {c}" problem = f"{a}x + {b} = {c}"
solution = x solution = x
return problem, solution return problem, solution
def logFunc(maxBase=3, maxVal=8): def logFunc(maxBase=3, maxVal=8):
a = random.randint(1, maxVal) a = random.randint(1, maxVal)
b = random.randint(2, maxBase) b = random.randint(2, maxBase)
c = pow(b,a) c = pow(b, a)
problem = "log"+str(b)+"("+str(c)+")" problem = "log" + str(b) + "(" + str(c) + ")"
solution = str(a) solution = str(a)
return problem, solution return problem, solution
def divisionToIntFunc(maxA=25, maxB=25): def divisionToIntFunc(maxA=25, maxB=25):
a = random.randint(1,maxA) a = random.randint(1, maxA)
b = random.randint(1,maxB) b = random.randint(1, maxB)
divisor = a*b divisor = a * b
dividend=random.choice([a,b]) dividend = random.choice([a, b])
problem = f"{divisor}/{dividend} = " problem = f"{divisor}/{dividend} = "
solution=int(divisor/dividend) solution = int(divisor / dividend)
return problem,solution return problem, solution
def DecimalToBinaryFunc(max_dec=99): def DecimalToBinaryFunc(max_dec=99):
a = random.randint(1, max_dec) a = random.randint(1, max_dec)
b = bin(a).replace("0b", "") b = bin(a).replace("0b", "")
problem = "Binary of "+str(a)+"=" problem = "Binary of " + str(a) + "="
solution = str(b) solution = str(b)
return problem, solution return problem, solution
def BinaryToDecimalFunc(max_dig=10):
problem=''
for i in range(random.randint(1,max_dig)):
temp = str(random.randint(0, 1))
problem += temp
solution=int(problem, 2); def BinaryToDecimalFunc(max_dig=10):
return problem, solution problem = ''
for i in range(random.randint(1, max_dig)):
temp = str(random.randint(0, 1))
problem += temp
solution = int(problem, 2)
return problem, solution
def divideFractionsFunc(maxVal=10): def divideFractionsFunc(maxVal=10):
a = random.randint(1, maxVal) a = random.randint(1, maxVal)
@@ -193,6 +214,7 @@ def divideFractionsFunc(maxVal=10):
d = random.randint(1, maxVal) d = random.randint(1, maxVal)
while (c == d): while (c == d):
d = random.randint(1, maxVal) d = random.randint(1, maxVal)
def calculate_gcd(x, y): def calculate_gcd(x, y):
while(y): while(y):
x, y = y, x % y x, y = y, x % y
@@ -208,33 +230,36 @@ def divideFractionsFunc(maxVal=10):
solution = x solution = x
return problem, solution return problem, solution
def multiplyIntToMatrix22(maxMatrixVal = 10, maxRes = 100):
def multiplyIntToMatrix22(maxMatrixVal=10, maxRes=100):
a = random.randint(0, maxMatrixVal) a = random.randint(0, maxMatrixVal)
b = random.randint(0, maxMatrixVal) b = random.randint(0, maxMatrixVal)
c = random.randint(0, maxMatrixVal) c = random.randint(0, maxMatrixVal)
d = random.randint(0, maxMatrixVal) d = random.randint(0, maxMatrixVal)
constant = random.randint(0, int(maxRes/max(a,b,c,d))) constant = random.randint(0, int(maxRes / max(a, b, c, d)))
problem = f"{constant} * [[{a}, {b}], [{c}, {d}]] = " problem = f"{constant} * [[{a}, {b}], [{c}, {d}]] = "
solution = f"[[{a*constant},{b*constant}],[{c*constant},{d*constant}]]" solution = f"[[{a*constant},{b*constant}],[{c*constant},{d*constant}]]"
return problem, solution 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): 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) sideA = random.randint(1, maxSideLength)
sideB = random.randint(1, maxSideLength) sideB = random.randint(1, maxSideLength)
sideC = random.randint(1, maxSideLength) sideC = random.randint(1, maxSideLength)
sideSums = [sideA + sideB, sideB + sideC, sideC + sideA] sideSums = [sideA + sideB, sideB + sideC, sideC + sideA]
sides = [sideC, sideA, sideB] sides = [sideC, sideA, sideB]
exists = True & (sides[0] < sideSums[0]) & (sides[1] < sideSums[1]) & (sides[2] < sideSums[2]) 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?" problem = f"Does triangle with sides {sideA}, {sideB} and {sideC} exist?"
if exists: if exists:
solution = "Yes" solution = "Yes"
@@ -242,51 +267,56 @@ def isTriangleValidFunc(maxSideLength = 50):
solution = "No" solution = "No"
return problem, solution return problem, solution
def MidPointOfTwoPointFunc(maxValue=20): def MidPointOfTwoPointFunc(maxValue=20):
x1=random.randint(-20,maxValue) x1 = random.randint(-20, maxValue)
y1=random.randint(-20,maxValue) y1 = random.randint(-20, maxValue)
x2=random.randint(-20,maxValue) x2 = random.randint(-20, maxValue)
y2=random.randint(-20,maxValue) y2 = random.randint(-20, maxValue)
problem=f"({x1},{y1}),({x2},{y2})=" problem = f"({x1},{y1}),({x2},{y2})="
solution=f"({(x1+x2)/2},{(y1+y2)/2})" solution = f"({(x1+x2)/2},{(y1+y2)/2})"
return problem,solution 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) def factoringFunc(range_x1=10, range_x2=10):
c = intParser(x1 * x2) 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
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): def thirdAngleOfTriangleFunc(maxAngle=89):
angle1 = random.randint(1, maxAngle) angle1 = random.randint(1, maxAngle)
angle2 = random.randint(1, maxAngle) angle2 = random.randint(1, maxAngle)
angle3 = 180 - (angle1 + angle2) angle3 = 180 - (angle1 + angle2)
problem = f"Third angle of triangle with angles {angle1} and {angle2} = " problem = f"Third angle of triangle with angles {angle1} and {angle2} = "
solution = angle3 solution = angle3
return problem, solution return problem, solution
def systemOfEquationsFunc(range_x = 10, range_y = 10, coeff_mult_range=10):
def systemOfEquationsFunc(range_x=10, range_y=10, coeff_mult_range=10):
# Generate solution point first # Generate solution point first
x = random.randint(-range_x, range_x) x = random.randint(-range_x, range_x)
y = random.randint(-range_y, range_y) y = random.randint(-range_y, range_y)
@@ -331,17 +361,19 @@ def systemOfEquationsFunc(range_x = 10, range_y = 10, coeff_mult_range=10):
# Add random (non-zero) multiple of equations to each other # Add random (non-zero) multiple of equations to each other
def distanceTwoPointsFunc(maxValXY = 20, minValXY=-20):
point1X = random.randint(minValXY, maxValXY+1) def distanceTwoPointsFunc(maxValXY=20, minValXY=-20):
point1Y = random.randint(minValXY, maxValXY+1) point1X = random.randint(minValXY, maxValXY + 1)
point2X = random.randint(minValXY, maxValXY+1) point1Y = random.randint(minValXY, maxValXY + 1)
point2Y = random.randint(minValXY, maxValXY+1) point2X = random.randint(minValXY, maxValXY + 1)
point2Y = random.randint(minValXY, maxValXY + 1)
distanceSq = (point1X - point2X) ** 2 + (point1Y - point2Y) ** 2 distanceSq = (point1X - point2X) ** 2 + (point1Y - point2Y) ** 2
solution = f"sqrt({distanceSq})" solution = f"sqrt({distanceSq})"
problem = f"Find the distance between ({point1X}, {point1Y}) and ({point2X}, {point2Y})" problem = f"Find the distance between ({point1X}, {point1Y}) and ({point2X}, {point2Y})"
return problem, solution return problem, solution
def pythagoreanTheoremFunc(maxLength = 20):
def pythagoreanTheoremFunc(maxLength=20):
a = random.randint(1, maxLength) a = random.randint(1, maxLength)
b = random.randint(1, maxLength) b = random.randint(1, maxLength)
c = (a**2 + b**2)**0.5 c = (a**2 + b**2)**0.5
@@ -349,29 +381,31 @@ def pythagoreanTheoremFunc(maxLength = 20):
solution = f"{c:.0f}" if c.is_integer() else f"{c:.2f}" solution = f"{c:.0f}" if c.is_integer() else f"{c:.2f}"
return problem, solution return problem, solution
def linearEquationsFunc(n = 2, varRange = 20, coeffRange = 20):
def linearEquationsFunc(n=2, varRange=20, coeffRange=20):
if n > 10: if n > 10:
print("[!] n cannot be greater than 10") print("[!] n cannot be greater than 10")
return None, None return None, None
vars = ['x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g'][:n] vars = ['x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g'][:n]
soln = [ random.randint(-varRange, varRange) for i in range(n) ] soln = [random.randint(-varRange, varRange) for i in range(n)]
problem = list() problem = list()
solution = ", ".join(["{} = {}".format(vars[i], soln[i]) for i in range(n)]) solution = ", ".join(["{} = {}".format(vars[i], soln[i]) for i in range(n)])
for _ in range(n): for _ in range(n):
coeff = [ random.randint(-coeffRange, coeffRange) for i in range(n) ] coeff = [random.randint(-coeffRange, coeffRange) for i in range(n)]
res = sum([ coeff[i] * soln[i] 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)] prob = ["{}{}".format(coeff[i], vars[i]) if coeff[i] != 0 else "" for i in range(n)]
while "" in prob: while "" in prob:
prob.remove("") prob.remove("")
prob = " + ".join(prob) + " = " + str(res) prob = " + ".join(prob) + " = " + str(res)
problem.append(prob) problem.append(prob)
problem = "\n".join(problem) problem = "\n".join(problem)
return problem, solution return problem, solution
def primeFactorsFunc(minVal=1, maxVal=200): def primeFactorsFunc(minVal=1, maxVal=200):
a = random.randint(minVal, maxVal) a = random.randint(minVal, maxVal)
n = a n = a
@@ -389,6 +423,7 @@ def primeFactorsFunc(minVal=1, maxVal=200):
solution = f"{factors}" solution = f"{factors}"
return problem, solution return problem, solution
def multiplyFractionsFunc(maxVal=10): def multiplyFractionsFunc(maxVal=10):
a = random.randint(1, maxVal) a = random.randint(1, maxVal)
b = random.randint(1, maxVal) b = random.randint(1, maxVal)
@@ -398,6 +433,7 @@ def multiplyFractionsFunc(maxVal=10):
b = random.randint(1, maxVal) b = random.randint(1, maxVal)
while (c == d): while (c == d):
d = random.randint(1, maxVal) d = random.randint(1, maxVal)
def calculate_gcd(x, y): def calculate_gcd(x, y):
while(y): while(y):
x, y = y, x % y x, y = y, x % y
@@ -412,32 +448,33 @@ def multiplyFractionsFunc(maxVal=10):
solution = x solution = x
return problem, solution return problem, solution
def regularPolygonAngleFunc(minVal = 3,maxVal = 20):
def regularPolygonAngleFunc(minVal=3, maxVal=20):
sideNum = random.randint(minVal, maxVal) sideNum = random.randint(minVal, maxVal)
problem = f"Find the angle of a regular polygon with {sideNum} sides" problem = f"Find the angle of a regular polygon with {sideNum} sides"
exteriorAngle = round((360/sideNum),2) exteriorAngle = round((360 / sideNum), 2)
solution = 180 - exteriorAngle solution = 180 - exteriorAngle
return problem, solution return problem, solution
def combinationsFunc(maxlength=20): def combinationsFunc(maxlength=20):
def factorial(a): def factorial(a):
d=1 d = 1
for i in range(a): for i in range(a):
a=(i+1)*d a = (i + 1) * d
d=a d = a
return d return d
a= random.randint(10,maxlength) a = random.randint(10, maxlength)
b=random.randint(0,9) 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)
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 return problem, solution
def factorialFunc(maxInput = 6):
def factorialFunc(maxInput=6):
a = random.randint(0, maxInput) a = random.randint(0, maxInput)
n = a n = a
problem = str(a) + "! = " problem = str(a) + "! = "
@@ -452,31 +489,35 @@ def factorialFunc(maxInput = 6):
solution = str(b) solution = str(b)
return problem, solution return problem, solution
def surfaceAreaCube(maxSide = 20, unit = 'm'):
def surfaceAreaCube(maxSide=20, unit='m'):
a = random.randint(1, maxSide) a = random.randint(1, maxSide)
problem = f"Surface area of cube with side = {a}{unit} is" problem = f"Surface area of cube with side = {a}{unit} is"
ans = 6 * a * a ans = 6 * a * a
solution = f"{ans} {unit}^2" solution = f"{ans} {unit}^2"
return problem, solution return problem, solution
def volumeCube(maxSide = 20, unit = 'm'):
def volumeCube(maxSide=20, unit='m'):
a = random.randint(1, maxSide) a = random.randint(1, maxSide)
problem = f"Volume of cube with side = {a}{unit} is" problem = f"Volume of cube with side = {a}{unit} is"
ans = a * a * a ans = a * a * a
solution = f"{ans} {unit}^3" solution = f"{ans} {unit}^3"
return problem, solution return problem, solution
def surfaceAreaCuboid(maxSide = 20, unit = 'm'):
def surfaceAreaCuboid(maxSide=20, unit='m'):
a = random.randint(1, maxSide) a = random.randint(1, maxSide)
b = random.randint(1, maxSide) b = random.randint(1, maxSide)
c = random.randint(1, maxSide) c = random.randint(1, maxSide)
problem = f"Surface area of cuboid with sides = {a}{unit}, {b}{unit}, {c}{unit} is" problem = f"Surface area of cuboid with sides = {a}{unit}, {b}{unit}, {c}{unit} is"
ans = 2 * (a*b + b*c + c*a) ans = 2 * (a * b + b * c + c * a)
solution = f"{ans} {unit}^2" solution = f"{ans} {unit}^2"
return problem, solution return problem, solution
def volumeCuboid(maxSide = 20, unit = 'm'):
def volumeCuboid(maxSide=20, unit='m'):
a = random.randint(1, maxSide) a = random.randint(1, maxSide)
b = random.randint(1, maxSide) b = random.randint(1, maxSide)
c = random.randint(1, maxSide) c = random.randint(1, maxSide)
@@ -485,7 +526,8 @@ def volumeCuboid(maxSide = 20, unit = 'm'):
solution = f"{ans} {unit}^3" solution = f"{ans} {unit}^3"
return problem, solution return problem, solution
def surfaceAreaCylinder(maxRadius = 20, maxHeight = 50,unit = 'm'):
def surfaceAreaCylinder(maxRadius=20, maxHeight=50, unit='m'):
a = random.randint(1, maxHeight) a = random.randint(1, maxHeight)
b = random.randint(1, maxRadius) b = random.randint(1, maxRadius)
problem = f"Surface area of cylinder with height = {a}{unit} and radius = {b}{unit} is" problem = f"Surface area of cylinder with height = {a}{unit} and radius = {b}{unit} is"
@@ -493,7 +535,8 @@ def surfaceAreaCylinder(maxRadius = 20, maxHeight = 50,unit = 'm'):
solution = f"{ans} {unit}^2" solution = f"{ans} {unit}^2"
return problem, solution return problem, solution
def volumeCylinder(maxRadius = 20, maxHeight = 50, unit = 'm'):
def volumeCylinder(maxRadius=20, maxHeight=50, unit='m'):
a = random.randint(1, maxHeight) a = random.randint(1, maxHeight)
b = random.randint(1, maxRadius) b = random.randint(1, maxRadius)
problem = f"Volume of cylinder with height = {a}{unit} and radius = {b}{unit} is" problem = f"Volume of cylinder with height = {a}{unit} and radius = {b}{unit} is"
@@ -501,7 +544,8 @@ def volumeCylinder(maxRadius = 20, maxHeight = 50, unit = 'm'):
solution = f"{ans} {unit}^3" solution = f"{ans} {unit}^3"
return problem, solution return problem, solution
def surfaceAreaCone(maxRadius = 20, maxHeight = 50,unit = 'm'):
def surfaceAreaCone(maxRadius=20, maxHeight=50, unit='m'):
a = random.randint(1, maxHeight) a = random.randint(1, maxHeight)
b = random.randint(1, maxRadius) b = random.randint(1, maxRadius)
slopingHeight = math.sqrt(a**2 + b**2) slopingHeight = math.sqrt(a**2 + b**2)
@@ -510,14 +554,16 @@ def surfaceAreaCone(maxRadius = 20, maxHeight = 50,unit = 'm'):
solution = f"{ans} {unit}^2" solution = f"{ans} {unit}^2"
return problem, solution return problem, solution
def volumeCone(maxRadius = 20, maxHeight = 50, unit = 'm'):
def volumeCone(maxRadius=20, maxHeight=50, unit='m'):
a = random.randint(1, maxHeight) a = random.randint(1, maxHeight)
b = random.randint(1, maxRadius) b = random.randint(1, maxRadius)
problem = f"Volume of cone with height = {a}{unit} and radius = {b}{unit} is" problem = f"Volume of cone with height = {a}{unit} and radius = {b}{unit} is"
ans = int(math.pi * b * b * a * (1/3)) ans = int(math.pi * b * b * a * (1 / 3))
solution = f"{ans} {unit}^3" solution = f"{ans} {unit}^3"
return problem, solution return problem, solution
def commonFactorsFunc(maxVal=100): def commonFactorsFunc(maxVal=100):
a = random.randint(1, maxVal) a = random.randint(1, maxVal)
b = random.randint(1, maxVal) b = random.randint(1, maxVal)
@@ -537,6 +583,7 @@ def commonFactorsFunc(maxVal=100):
solution = arr solution = arr
return problem, solution return problem, solution
def intersectionOfTwoLinesFunc( def intersectionOfTwoLinesFunc(
minM=-10, maxM=10, minB=-10, maxB=10, minDenominator=1, maxDenominator=6 minM=-10, maxM=10, minB=-10, maxB=10, minDenominator=1, maxDenominator=6
): ):
@@ -567,7 +614,7 @@ def intersectionOfTwoLinesFunc(
else: else:
x = f"{x.numerator}/{x.denominator}" x = f"{x.numerator}/{x.denominator}"
return x return x
m1 = (random.randint(minM, maxM), random.randint(minDenominator, maxDenominator)) m1 = (random.randint(minM, maxM), random.randint(minDenominator, maxDenominator))
m2 = (random.randint(minM, maxM), random.randint(minDenominator, maxDenominator)) m2 = (random.randint(minM, maxM), random.randint(minDenominator, maxDenominator))
b1 = random.randint(minB, maxB) b1 = random.randint(minB, maxB)
@@ -590,21 +637,24 @@ def intersectionOfTwoLinesFunc(
solution = f"({fractionToString(intersection_x)}, {fractionToString(intersection_y)})" solution = f"({fractionToString(intersection_x)}, {fractionToString(intersection_y)})"
return problem, solution return problem, solution
def permutationFunc(maxlength=20): def permutationFunc(maxlength=20):
a = random.randint(10,maxlength) a = random.randint(10, maxlength)
b = random.randint(0,9) b = random.randint(0, 9)
solution= int(math.factorial(a)/(math.factorial(a-b))) solution = int(math.factorial(a) / (math.factorial(a - b)))
problem= "Number of Permutations from {} objects picked {} at a time = ".format(a,b) problem = "Number of Permutations from {} objects picked {} at a time = ".format(a, b)
return problem, solution return problem, solution
def vectorCrossFunc(minVal=-20, maxVal=20): def vectorCrossFunc(minVal=-20, maxVal=20):
a = [random.randint(minVal, maxVal) for i in range(3)] a = [random.randint(minVal, maxVal) for i in range(3)]
b = [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], c = [a[1] * b[2] - a[2] * b[1],
a[2]*b[0] - a[0]*b[2], a[2] * b[0] - a[0] * b[2],
a[0]*b[1] - a[1]*b[0]] a[0] * b[1] - a[1] * b[0]]
return str(a) + " X " + str(b) + " = ", str(c) return str(a) + " X " + str(b) + " = ", str(c)
def compareFractionsFunc(maxVal=10): def compareFractionsFunc(maxVal=10):
a = random.randint(1, maxVal) a = random.randint(1, maxVal)
b = random.randint(1, maxVal) b = random.randint(1, maxVal)
@@ -616,79 +666,84 @@ def compareFractionsFunc(maxVal=10):
while (c == d): while (c == d):
d = random.randint(1, maxVal) d = random.randint(1, maxVal)
first=a/b first = a / b
second=c/d second = c / d
if(first>second): if(first > second):
solution=">" solution = ">"
elif(first<second): elif(first < second):
solution="<" solution = "<"
else: else:
solution="=" solution = "="
problem = f"Which symbol represents the comparison between {a}/{b} and {c}/{d}?" problem = f"Which symbol represents the comparison between {a}/{b} and {c}/{d}?"
return problem,solution 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 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): def matrixMultiplicationFunc(maxVal=100):
m= random.randint(2, 10) m = random.randint(2, 10)
n= random.randint(2, 10) n = random.randint(2, 10)
k= random.randint(2, 10) k = random.randint(2, 10)
#generate matrices a and b # generate matrices a and b
a=[] a = []
for r in range(m): for r in range(m):
a.append([]) a.append([])
for c in range(n): for c in range(n):
a[r].append(random.randint(-maxVal,maxVal)) a[r].append(random.randint(-maxVal, maxVal))
b=[] b = []
for r in range(n): for r in range(n):
b.append([]) b.append([])
for c in range(k): for c in range(k):
b[r].append(random.randint(-maxVal, maxVal)) b[r].append(random.randint(-maxVal, maxVal))
res= [] res = []
a_string= matrixMultiplicationFuncHelper(a) a_string = matrixMultiplicationFuncHelper(a)
b_string= matrixMultiplicationFuncHelper(b) b_string = matrixMultiplicationFuncHelper(b)
for r in range(m): for r in range(m):
res.append([]) res.append([])
for c in range(k): for c in range(k):
temp= 0 temp = 0
for t in range(n): for t in range(n):
temp+=a[r][t]*b[t][c] temp += a[r][t] * b[t][c]
res[r].append(temp) 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 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) solution = matrixMultiplicationFuncHelper(res)
return problem, solution return problem, solution
def matrixMultiplicationFuncHelper(inp): def matrixMultiplicationFuncHelper(inp):
m= len(inp) m = len(inp)
n= len(inp[0]) n = len(inp[0])
string= "" string = ""
for i in range(m): for i in range(m):
for j in range(n): for j in range(n):
string+=f"{inp[i][j]: 6d}" string += f"{inp[i][j]: 6d}"
string+=" " string += " "
string+="\n" string += "\n"
return string return string
def cubeRootFunc(minNo = 1, maxNo = 1000):
def cubeRootFunc(minNo=1, maxNo=1000):
b = random.randint(minNo, maxNo) b = random.randint(minNo, maxNo)
a = b**(1/3) a = b**(1 / 3)
problem = "cuberoot of " + str(b) + " upto 2 decimal places is:" problem = "cuberoot of " + str(b) + " upto 2 decimal places is:"
solution = str(round(a,2)) solution = str(round(a, 2))
return problem, solution return problem, solution
def powerRuleIntegrationFunc(maxCoef = 10, maxExp = 10, maxTerms = 5):
def powerRuleIntegrationFunc(maxCoef=10, maxExp=10, maxTerms=5):
numTerms = random.randint(1, maxTerms) numTerms = random.randint(1, maxTerms)
problem = "" problem = ""
solution = "" solution = ""
@@ -699,39 +754,40 @@ def powerRuleIntegrationFunc(maxCoef = 10, maxExp = 10, maxTerms = 5):
coefficient = random.randint(1, maxCoef) coefficient = random.randint(1, maxCoef)
exponent = random.randint(1, maxExp) exponent = random.randint(1, maxExp)
problem += str(coefficient) + "x^" + str(exponent) problem += str(coefficient) + "x^" + str(exponent)
solution += "("+str(coefficient) +"/"+str(exponent + 1) +")x^" + str(exponent +1) solution += "(" + str(coefficient) + "/" + str(exponent) + ")x^" + str(exponent + 1)
solution = solution + " + c" solution = solution + " + c"
return problem, solution return problem, solution
def fourthAngleOfQuadriFunc(maxAngle = 180): def fourthAngleOfQuadriFunc(maxAngle=180):
angle1 = random.randint(1, maxAngle) angle1 = random.randint(1, maxAngle)
angle2 = random.randint(1, 240-angle1) angle2 = random.randint(1, 240 - angle1)
angle3 = random.randint(1, 340-(angle1 + angle2)) angle3 = random.randint(1, 340 - (angle1 + angle2))
sum_ = angle1 + angle2 + angle3 sum_ = angle1 + angle2 + angle3
angle4 = 360 - sum_ angle4 = 360 - sum_
problem = f"Fourth angle of quadrilateral with angles {angle1} , {angle2}, {angle3} =" problem = f"Fourth angle of quadrilateral with angles {angle1} , {angle2}, {angle3} ="
solution = angle4 solution = angle4
return problem, solution return problem, solution
def quadraticEquation(maxVal=100):
a = random.randint(1,maxVal)
c = random.randint(1,maxVal)
b = random.randint(round(math.sqrt(4*a*c))+1,round(math.sqrt(4*maxVal*maxVal)))
problem = "Zeros of the Quadratic Equation {}x^2+{}x+{}=0".format(a,b,c)
D = math.sqrt(b*b-4*a*c)
def quadraticEquation(maxVal=100):
solution = str([round((-b+D)/(2*a), 2),round((-b-D)/(2*a), 2)]) a = random.randint(1, maxVal)
return problem,solution c = random.randint(1, maxVal)
b = random.randint(round(math.sqrt(4 * a * c)) + 1, round(math.sqrt(4 * maxVal * maxVal)))
problem = "Zeros of the Quadratic Equation {}x^2+{}x+{}=0".format(a, b, c)
D = math.sqrt(b * b - 4 * a * c)
solution = str([round((-b + D) / (2 * a), 2), round((-b - D) / (2 * a), 2)])
return problem, solution
def hcfFunc(maxVal=20): def hcfFunc(maxVal=20):
a = random.randint(1, maxVal) a = random.randint(1, maxVal)
b = random.randint(1, maxVal) b = random.randint(1, maxVal)
x, y = a, b x, y = a, b
while(y): while(y):
x, y = y, x % y x, y = y, x % y
problem = f"HCF of {a} and {b} = " problem = f"HCF of {a} and {b} = "
solution = str(x) solution = str(x)
return problem, solution return problem, solution
@@ -797,18 +853,18 @@ def surdsComparisonFunc(maxValue = 100, maxRoot = 10):
elif first < second: elif first < second:
solution = "<" solution = "<"
return problem, solution return problem, solution
def fibonacciSeriesFunc(minNo=1): def fibonacciSeriesFunc(minNo=1):
n = random.randint(minNo,20) n = random.randint(minNo,20)
def createFibList(n): def createFibList(n):
l=[] l=[]
for i in range(n): for i in range(n):
if i<2: if i<2:
l.append(i) l.append(i)
else: else:
val = l[i-1]+l[i-2] val = l[i-1]+l[i-2]
l.append(val) l.append(val)
return l return l
fibList=createFibList(n) fibList=createFibList(n)
problem = "The Fibonacci Series of the first "+str(n)+" numbers is ?" problem = "The Fibonacci Series of the first "+str(n)+" numbers is ?"
solution = fibList solution = fibList
@@ -821,7 +877,7 @@ def basicTrigonometryFunc(angles=[0,30,45,60,90],functions=["sin","cos","tan"]):
problem=f"What is {function}({angle})?" problem=f"What is {function}({angle})?"
expression='math.'+function+'(math.radians(angle))' expression='math.'+function+'(math.radians(angle))'
result_fraction_map={0.0:"0",0.5:"1/2",0.71:"1/√2",0.87:"√3/2",1.0:"1",0.58:"1/√3",1.73:"√3"} result_fraction_map={0.0:"0",0.5:"1/2",0.71:"1/√2",0.87:"√3/2",1.0:"1",0.58:"1/√3",1.73:"√3"}
solution=result_fraction_map[round(eval(expression),2)] if round(eval(expression),2)<=99999 else "∞" #for handling the ∞ condition solution=result_fraction_map[round(eval(expression),2)] if round(eval(expression),2)<=99999 else "∞" #for handling the ∞ condition
return problem,solution return problem,solution
@@ -833,10 +889,41 @@ def sumOfAnglesOfPolygonFunc(maxSides = 12):
solution = sum solution = sum
return problem, solution return problem, solution
def dataSummaryFunc(number_values=15,minval=5,maxval=50):
random_list=[]
for i in range(number_values):
n=random.randint(minval,maxval)
random_list.append(n)
a=sum(random_list)
mean=a/number_values
var=0
for i in range(number_values):
var+=(random_list[i]-mean)**2
print(random_list)
print(mean)
print(var/number_values)
print((var/number_values)**0.5)
problem="Find the mean,standard deviation and variance for the data"+str(random_list)
solution="The Mean is {} , Standard Deviation is {}, Variance is {}".format(mean,var/number_values,(var/number_values)**0.5)
return problem,solution
def surfaceAreaSphere(maxSide = 20, unit = 'm'):
r = random.randint(1, maxSide)
problem = f"Surface area of Sphere with radius = {r}{unit} is"
ans = 4 * math.pi * r * r
solution = f"{ans} {unit}^2"
return problem, solution
def volumeSphereFunc(maxRadius = 100):
r=random.randint(1,maxRadius)
problem=f"Volume of sphere with radius {r} m = "
ans=(4*math.pi/3)*r*r*r
solution = f"{ans} m^3"
return problem,solution
# || Class Instances # || Class Instances
#Format is: # Format is:
#<title> = Generator("<Title>", <id>, <generalized problem>, <generalized solution>, <function name>) # <title> = Generator("<Title>", <id>, <generalized problem>, <generalized solution>, <function name>)
addition = Generator("Addition", 0, "a+b=", "c", additionFunc) addition = Generator("Addition", 0, "a+b=", "c", additionFunc)
subtraction = Generator("Subtraction", 1, "a-b=", "c", subtractionFunc) subtraction = Generator("Subtraction", 1, "a-b=", "c", subtractionFunc)
multiplication = Generator("Multiplication", 2, "a*b=", "c", multiplicationFunc) multiplication = Generator("Multiplication", 2, "a*b=", "c", multiplicationFunc)
@@ -845,49 +932,48 @@ binaryComplement1s = Generator("Binary Complement 1s", 4, "1010=", "0101", binar
moduloDivision = Generator("Modulo Division", 5, "a%b=", "c", moduloFunc) moduloDivision = Generator("Modulo Division", 5, "a%b=", "c", moduloFunc)
squareRoot = Generator("Square Root", 6, "sqrt(a)=", "b", squareRootFunc) squareRoot = Generator("Square Root", 6, "sqrt(a)=", "b", squareRootFunc)
powerRuleDifferentiation = Generator("Power Rule Differentiation", 7, "nx^m=", "(n*m)x^(m-1)", powerRuleDifferentiationFunc) powerRuleDifferentiation = Generator("Power Rule Differentiation", 7, "nx^m=", "(n*m)x^(m-1)", powerRuleDifferentiationFunc)
square = Generator("Square", 8,"a^2", "b", squareFunc) square = Generator("Square", 8, "a^2", "b", squareFunc)
lcm = Generator("LCM (Least Common Multiple)", 9, "LCM of a and b = ", "c", lcmFunc) lcm = Generator("LCM (Least Common Multiple)", 9, "LCM of a and b = ", "c", lcmFunc)
gcd = Generator("GCD (Greatest Common Denominator)", 10, "GCD of a and b = ", "c", gcdFunc) gcd = Generator("GCD (Greatest Common Denominator)", 10, "GCD of a and b = ", "c", gcdFunc)
basicAlgebra = Generator("Basic Algebra", 11, "ax + b = c", "d", basicAlgebraFunc) basicAlgebra = Generator("Basic Algebra", 11, "ax + b = c", "d", basicAlgebraFunc)
log = Generator("Logarithm", 12, "log2(8)", "3", logFunc) log = Generator("Logarithm", 12, "log2(8)", "3", logFunc)
intDivision = Generator("Easy Division", 13,"a/b=","c",divisionToIntFunc) intDivision = Generator("Easy Division", 13, "a/b=", "c", divisionToIntFunc)
decimalToBinary = Generator("Decimal to Binary",14,"Binary of a=","b",DecimalToBinaryFunc) decimalToBinary = Generator("Decimal to Binary", 14, "Binary of a=", "b", DecimalToBinaryFunc)
binaryToDecimal = Generator("Binary to Decimal",15,"Decimal of a=","b",BinaryToDecimalFunc) binaryToDecimal = Generator("Binary to Decimal", 15, "Decimal of a=", "b", BinaryToDecimalFunc)
fractionDivision = Generator("Fraction Division", 16, "(a/b)/(c/d)=", "x/y", divideFractionsFunc) 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) 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) 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) 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) 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) 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) 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", systemOfEquations = Generator("Solve a System of Equations in R^2", 23, "2x + 5y = 13, -3x - 3y = -6", "x = -1, y = 3",systemOfEquationsFunc)
systemOfEquationsFunc) distance2Point = Generator("Distance between 2 points", 24, "Find the distance between (x1,y1) and (x2,y2)", "sqrt(distanceSquared)", distanceTwoPointsFunc)
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) 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 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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+1)x^(m+1)", powerRuleIntegrationFunc) 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) fourthAngleOfQuadrilateral = Generator("Fourth Angle of Quadrilateral", 49, "Fourth angle of Quadrilateral with angles a,b,c =", "angle4", fourthAngleOfQuadriFunc)
quadraticEquationSolve = Generator("Quadratic Equation", 50, "Find the zeros {x1,x2} of the quadratic equation ax^2+bx+c=0", "x1,x2", quadraticEquation) quadraticEquationSolve = Generator("Quadratic Equation", 50, "Find the zeros {x1,x2} of the quadratic equation ax^2+bx+c=0", "x1,x2", quadraticEquation)
hcf = Generator("HCF (Highest Common Factor)", 51, "HCF of a and b = ", "c", hcfFunc) hcf = Generator("HCF (Highest Common Factor)", 51, "HCF of a and b = ", "c", hcfFunc)
diceSumProbability=Generator("Probability of a certain sum appearing on faces of dice", 52,"If n dices are rolled then probabilty of getting sum of x is =","z", DiceSumProbFunc) diceSumProbability=Generator("Probability of a certain sum appearing on faces of dice", 52,"If n dices are rolled then probabilty of getting sum of x is =","z", DiceSumProbFunc)
@@ -897,3 +983,6 @@ surdsComparison = Generator("Comparing surds", 55, "Fill in the blanks a^(1/b) _
fibonacciSeries = Generator("Fibonacci Series",56,"fibonacci series of first a numbers","prints the fibonacci series starting from 0 to a",fibonacciSeriesFunc) fibonacciSeries = Generator("Fibonacci Series",56,"fibonacci series of first a numbers","prints the fibonacci series starting from 0 to a",fibonacciSeriesFunc)
basicTrigonometry=Generator("Trigonometric Values",57,"What is sin(X)?","ans",basicTrigonometryFunc) basicTrigonometry=Generator("Trigonometric Values",57,"What is sin(X)?","ans",basicTrigonometryFunc)
sumOfAnglesOfPolygon = Generator("Sum of Angles of Polygon", 58, "Sum of angles of polygon with n sides = ", "sum", sumOfAnglesOfPolygonFunc) sumOfAnglesOfPolygon = Generator("Sum of Angles of Polygon", 58, "Sum of angles of polygon with n sides = ", "sum", sumOfAnglesOfPolygonFunc)
dataSummary = Generator("Mean,Standard Deviation,Variance", 59, "a,b,c", "Mean:a+b+c/3,Std,Var", dataSummaryFunc)
surfaceAreaSphereGen = Generator("Surface Area of Sphere", 59, "Surface area of sphere with radius = a units is","d units^2", surfaceAreaSphere)
volumeSphere=Generator("Volume of Sphere",60,"Volume of sphere with radius r m = ","(4*pi/3)*r*r*r",volumeSphereFunc)

2
setup.py
View File

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

24
tests/test_mathgen.py
View File

@@ -5,42 +5,42 @@ from hypothesis import strategies as st, given, assume
@given(maxSum=st.integers(min_value=1), maxAddend=st.integers(min_value=1)) @given(maxSum=st.integers(min_value=1), maxAddend=st.integers(min_value=1))
def test_additionFunc(maxSum, maxAddend): def test_addition(maxSum, maxAddend):
assume(maxSum > maxAddend) assume(maxSum > maxAddend)
problem, solution = additionFunc(maxSum, maxAddend) problem, solution = addition.func(maxSum, maxAddend)
assert eval(problem[:-1]) == int(solution) assert eval(problem[:-1]) == int(solution)
@given(maxMinuend=st.integers(min_value=1), maxDiff=st.integers(min_value=1)) @given(maxMinuend=st.integers(min_value=1), maxDiff=st.integers(min_value=1))
def test_subtractionFunc(maxMinuend, maxDiff): def test_subtraction(maxMinuend, maxDiff):
assume(maxMinuend > maxDiff) assume(maxMinuend > maxDiff)
problem, solution = subtractionFunc(maxMinuend, maxDiff) problem, solution = subtraction.func(maxMinuend, maxDiff)
assert eval(problem[:-1]) == int(solution) assert eval(problem[:-1]) == int(solution)
@given(maxRes=st.integers(min_value=1), maxMulti=st.integers(min_value=1)) @given(maxRes=st.integers(min_value=1), maxMulti=st.integers(min_value=1))
def test_multiplicationFunc(maxRes, maxMulti): def test_multiplication(maxRes, maxMulti):
assume(maxRes > maxMulti) assume(maxRes > maxMulti)
problem, solution = multiplicationFunc(maxRes, maxMulti) problem, solution = multiplication.func(maxRes, maxMulti)
assert eval(problem[:-1]) == int(solution) assert eval(problem[:-1]) == int(solution)
@given(maxRes=st.integers(min_value=1), maxDivid=st.integers(min_value=1)) @given(maxRes=st.integers(min_value=1), maxDivid=st.integers(min_value=1))
def test_divisionFunc(maxRes, maxDivid): def test_division(maxRes, maxDivid):
assume(maxRes > maxDivid) assume(maxRes > maxDivid)
problem, solution = divisionFunc(maxRes, maxDivid) problem, solution = division.func(maxRes, maxDivid)
assert eval(problem[:-1]) == float(solution) assert eval(problem[:-1]) == float(solution)
@given(maxRes=st.integers(min_value=1), maxModulo=st.integers(min_value=1)) @given(maxRes=st.integers(min_value=1), maxModulo=st.integers(min_value=1))
def test_moduloFunc(maxRes, maxModulo): def test_moduloDivision(maxRes, maxModulo):
assume(maxRes > maxModulo) assume(maxRes > maxModulo)
problem, solution = moduloFunc(maxRes, maxModulo) problem, solution = moduloDivision.func(maxRes, maxModulo)
assert eval(problem[:-1]) == int(solution) assert eval(problem[:-1]) == int(solution)
@given(minNo=st.integers(min_value=1), maxNo=st.integers(min_value=1, max_value=2 ** 50)) @given(minNo=st.integers(min_value=1), maxNo=st.integers(min_value=1, max_value=2 ** 50))
def test_squareRootFunc(minNo, maxNo): def test_squareRoot(minNo, maxNo):
assume(maxNo > minNo) assume(maxNo > minNo)
problem, solution = squareRootFunc(minNo, maxNo) problem, solution = squareRoot.func(minNo, maxNo)
assert eval(problem[:-1]) == float(solution) assert eval(problem[:-1]) == float(solution)