From 08fc9d0663e90b96ee9d7cb7451aa3ee5c212576 Mon Sep 17 00:00:00 2001 From: YuvalG Date: Sat, 17 Oct 2020 20:05:47 +0300 Subject: [PATCH] Add flake8 as linter --- .github/workflows/tests.yaml | 44 +- Makefile | 9 +- dev-requirements.txt | 5 +- .../__pycache__/__init__.cpython-37.pyc | Bin 164 -> 0 bytes .../__pycache__/mathgen.cpython-37.pyc | Bin 19103 -> 0 bytes mathgenerator/mathgen.py | 500 ++++++++++-------- tests/test_mathgen.py | 92 ++-- 7 files changed, 358 insertions(+), 292 deletions(-) delete mode 100644 mathgenerator/__pycache__/__init__.cpython-37.pyc delete mode 100644 mathgenerator/__pycache__/mathgen.cpython-37.pyc diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml index 3252576..cc6cf9d 100644 --- a/.github/workflows/tests.yaml +++ b/.github/workflows/tests.yaml @@ -1,21 +1,23 @@ -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 +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: Linter + run: make lint + - name: Test + run: make test diff --git a/Makefile b/Makefile index dbf1f17..bd04e35 100644 --- a/Makefile +++ b/Makefile @@ -1,2 +1,7 @@ -test: - python -m pytest --verbose -s tests +FLAKE_FLAGS = --ignore=E501,F401,F403,F405 + +lint: + python -m flake8 $(FLAKE_FLAGS) + +test: + python -m pytest --verbose -s tests diff --git a/dev-requirements.txt b/dev-requirements.txt index a965899..6e46af4 100644 --- a/dev-requirements.txt +++ b/dev-requirements.txt @@ -1,2 +1,3 @@ -pytest -hypothesis \ No newline at end of file +pytest +hypothesis +flake8 \ No newline at end of file diff --git a/mathgenerator/__pycache__/__init__.cpython-37.pyc b/mathgenerator/__pycache__/__init__.cpython-37.pyc deleted file mode 100644 index 893336fc37f23c5d8be2b5e049b532e5ed6e2ea6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 164 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 diff --git a/mathgenerator/mathgen.py b/mathgenerator/mathgen.py index 7bf36d8..b8d9033 100644 --- a/mathgenerator/mathgen.py +++ b/mathgenerator/mathgen.py @@ -4,6 +4,7 @@ import fractions genList = [] + # || Generator class class Generator: def __init__(self, title, id, generalProb, generalSol, func): @@ -20,52 +21,59 @@ class Generator: def __call__(self, **kwargs): return self.func(**kwargs) + # || Non-generator Functions def genById(id): generator = genList[id][2] return(generator()) + def getGenList(): return(genList) # || Generator Functions -def additionFunc(maxSum = 99, maxAddend = 50): + +def additionFunc(maxSum=99, maxAddend=50): 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 - c = a+b + 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 problem = str(a) + "+" + str(b) + "=" solution = str(c) return problem, solution -def subtractionFunc(maxMinuend = 99, maxDiff = 99): + +def subtractionFunc(maxMinuend=99, maxDiff=99): a = random.randint(0, maxMinuend) - b = random.randint(max(0, (a-maxDiff)), a) - c = a-b + b = random.randint(max(0, (a - maxDiff)), a) + c = a - b problem = str(a) + "-" + str(b) + "=" solution = str(c) return problem, solution -def multiplicationFunc(maxRes = 99, maxMulti = 99): + +def multiplicationFunc(maxRes=99, maxMulti=99): a = random.randint(0, maxMulti) - b = random.randint(0, min(int(maxMulti/a), maxRes)) - c = a*b + b = random.randint(0, min(int(maxMulti / a), maxRes)) + c = a * b problem = str(a) + "*" + str(b) + "=" solution = str(c) return problem, solution -def divisionFunc(maxRes = 99, maxDivid = 99): + +def divisionFunc(maxRes=99, maxDivid=99): a = random.randint(0, maxDivid) b = random.randint(0, min(maxRes, maxDivid)) - c = a/b + c = a / b problem = str(a) + "/" + str(b) + "=" solution = str(c) return problem, solution -def binaryComplement1sFunc(maxDigits = 10): + +def binaryComplement1sFunc(maxDigits=10): question = '' answer = '' - for i in range(random.randint(1,maxDigits)): + for i in range(random.randint(1, maxDigits)): temp = str(random.randint(0, 1)) question += temp answer += "0" if temp == "1" else "1" @@ -74,22 +82,25 @@ def binaryComplement1sFunc(maxDigits = 10): solution = answer return problem, solution -def moduloFunc(maxRes = 99, maxModulo= 99): + +def moduloFunc(maxRes=99, maxModulo=99): a = random.randint(0, maxModulo) b = random.randint(0, min(maxRes, maxModulo)) - c = a%b + c = a % b problem = str(a) + "%" + str(b) + "=" solution = str(c) return problem, solution -def squareRootFunc(minNo = 1, maxNo = 12): + +def squareRootFunc(minNo=1, maxNo=12): b = random.randint(minNo, maxNo) - a = b*b + a = b * b problem = "sqrt(" + str(a) + ")=" solution = str(b) return problem, solution -def powerRuleDifferentiationFunc(maxCoef = 10, maxExp = 10, maxTerms = 5): + +def powerRuleDifferentiationFunc(maxCoef=10, maxExp=10, maxTerms=5): numTerms = random.randint(1, maxTerms) problem = "" solution = "" @@ -103,23 +114,26 @@ def powerRuleDifferentiationFunc(maxCoef = 10, maxExp = 10, maxTerms = 5): solution += str(coefficient * exponent) + "x^" + str(exponent - 1) return problem, solution -def squareFunc(maxSquareNum = 20): + +def squareFunc(maxSquareNum=20): a = random.randint(1, maxSquareNum) b = a * a problem = str(a) + "^2" + "=" solution = str(b) return problem, solution + def gcdFunc(maxVal=20): a = random.randint(1, maxVal) b = random.randint(1, maxVal) x, y = a, b while(y): - x, y = y, x % y + x, y = y, x % y problem = f"GCD of {a} and {b} = " solution = str(x) return problem, solution + def lcmFunc(maxVal=20): a = random.randint(1, maxVal) b = random.randint(1, maxVal) @@ -132,11 +146,13 @@ def lcmFunc(maxVal=20): solution = str(d) return problem, solution -def basicAlgebraFunc(maxVariable = 10): + +def basicAlgebraFunc(maxVariable=10): a = random.randint(1, maxVariable) b = random.randint(1, maxVariable) c = random.randint(b, maxVariable) # calculate gcd + def calculate_gcd(x, y): while(y): x, y = y, x % y @@ -145,44 +161,49 @@ def basicAlgebraFunc(maxVariable = 10): x = f"{(c - b)//i}/{a//i}" if (c - b == 0): x = "0" - elif a == 1 or a == i : + elif a == 1 or a == i: x = f"{c - b}" problem = f"{a}x + {b} = {c}" solution = x return problem, solution + def logFunc(maxBase=3, maxVal=8): a = random.randint(1, maxVal) b = random.randint(2, maxBase) - c = pow(b,a) - problem = "log"+str(b)+"("+str(c)+")" + c = pow(b, a) + problem = "log" + str(b) + "(" + str(c) + ")" solution = str(a) return problem, solution + def divisionToIntFunc(maxA=25, maxB=25): - a = random.randint(1,maxA) - b = random.randint(1,maxB) - divisor = a*b - dividend=random.choice([a,b]) + a = random.randint(1, maxA) + b = random.randint(1, maxB) + divisor = a * b + dividend = random.choice([a, b]) problem = f"{divisor}/{dividend} = " - solution=int(divisor/dividend) - return problem,solution + solution = int(divisor / dividend) + return problem, solution + def DecimalToBinaryFunc(max_dec=99): a = random.randint(1, max_dec) b = bin(a).replace("0b", "") - problem = "Binary of "+str(a)+"=" + problem = "Binary of " + str(a) + "=" solution = str(b) 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); - 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) + return problem, solution + def divideFractionsFunc(maxVal=10): a = random.randint(1, maxVal) @@ -193,6 +214,7 @@ def divideFractionsFunc(maxVal=10): d = random.randint(1, maxVal) while (c == d): d = random.randint(1, maxVal) + def calculate_gcd(x, y): while(y): x, y = y, x % y @@ -208,33 +230,36 @@ def divideFractionsFunc(maxVal=10): solution = x return problem, solution -def multiplyIntToMatrix22(maxMatrixVal = 10, maxRes = 100): + +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))) + 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): +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]) + 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" @@ -242,51 +267,56 @@ def isTriangleValidFunc(maxSideLength = 50): 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 + 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) +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 - 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 + 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): + +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) @@ -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 -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) + +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): + +def pythagoreanTheoremFunc(maxLength=20): a = random.randint(1, maxLength) b = random.randint(1, maxLength) 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}" return problem, solution -def linearEquationsFunc(n = 2, varRange = 20, coeffRange = 20): + +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) ] + 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)]) - + 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 @@ -389,6 +423,7 @@ def primeFactorsFunc(minVal=1, maxVal=200): solution = f"{factors}" return problem, solution + def multiplyFractionsFunc(maxVal=10): a = random.randint(1, maxVal) b = random.randint(1, maxVal) @@ -398,6 +433,7 @@ def multiplyFractionsFunc(maxVal=10): 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 @@ -412,32 +448,33 @@ def multiplyFractionsFunc(maxVal=10): solution = x return problem, solution -def regularPolygonAngleFunc(minVal = 3,maxVal = 20): + +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) + exteriorAngle = round((360 / sideNum), 2) solution = 180 - exteriorAngle - return problem, solution - + return problem, solution + + def combinationsFunc(maxlength=20): def factorial(a): - d=1 + d = 1 for i in range(a): - a=(i+1)*d - d=a + a = (i + 1) * d + d = a return d - a= random.randint(10,maxlength) - b=random.randint(0,9) + 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) - - 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): + + +def factorialFunc(maxInput=6): a = random.randint(0, maxInput) n = a problem = str(a) + "! = " @@ -452,31 +489,35 @@ def factorialFunc(maxInput = 6): solution = str(b) return problem, solution -def surfaceAreaCube(maxSide = 20, unit = 'm'): + +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'): + +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'): + +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) + ans = 2 * (a * b + b * c + c * a) solution = f"{ans} {unit}^2" return problem, solution -def volumeCuboid(maxSide = 20, unit = 'm'): + +def volumeCuboid(maxSide=20, unit='m'): a = random.randint(1, maxSide) b = random.randint(1, maxSide) c = random.randint(1, maxSide) @@ -485,7 +526,8 @@ def volumeCuboid(maxSide = 20, unit = 'm'): solution = f"{ans} {unit}^3" return problem, solution -def surfaceAreaCylinder(maxRadius = 20, maxHeight = 50,unit = 'm'): + +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" @@ -493,7 +535,8 @@ def surfaceAreaCylinder(maxRadius = 20, maxHeight = 50,unit = 'm'): solution = f"{ans} {unit}^2" return problem, solution -def volumeCylinder(maxRadius = 20, maxHeight = 50, unit = 'm'): + +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" @@ -501,7 +544,8 @@ def volumeCylinder(maxRadius = 20, maxHeight = 50, unit = 'm'): solution = f"{ans} {unit}^3" return problem, solution -def surfaceAreaCone(maxRadius = 20, maxHeight = 50,unit = 'm'): + +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) @@ -510,14 +554,16 @@ def surfaceAreaCone(maxRadius = 20, maxHeight = 50,unit = 'm'): solution = f"{ans} {unit}^2" return problem, solution -def volumeCone(maxRadius = 20, maxHeight = 50, unit = 'm'): + +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)) + 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) @@ -537,6 +583,7 @@ def commonFactorsFunc(maxVal=100): solution = arr return problem, solution + def intersectionOfTwoLinesFunc( minM=-10, maxM=10, minB=-10, maxB=10, minDenominator=1, maxDenominator=6 ): @@ -567,7 +614,7 @@ def intersectionOfTwoLinesFunc( 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) @@ -590,21 +637,24 @@ def intersectionOfTwoLinesFunc( 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) + 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]] + 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) @@ -616,79 +666,84 @@ def compareFractionsFunc(maxVal=10): while (c == d): d = random.randint(1, maxVal) - first=a/b - second=c/d + first = a / b + second = c / d - if(first>second): - solution=">" - elif(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 + 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 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=[] + 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=[] + 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) + res = [] + a_string = matrixMultiplicationFuncHelper(a) + b_string = matrixMultiplicationFuncHelper(b) for r in range(m): res.append([]) for c in range(k): - temp= 0 + temp = 0 for t in range(n): - temp+=a[r][t]*b[t][c] + 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) + 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= "" + 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" + string += f"{inp[i][j]: 6d}" + string += " " + string += "\n" return string -def cubeRootFunc(minNo = 1, maxNo = 1000): + +def cubeRootFunc(minNo=1, maxNo=1000): b = random.randint(minNo, maxNo) - a = b**(1/3) + a = b**(1 / 3) problem = "cuberoot of " + str(b) + " upto 2 decimal places is:" - solution = str(round(a,2)) + solution = str(round(a, 2)) return problem, solution -def powerRuleIntegrationFunc(maxCoef = 10, maxExp = 10, maxTerms = 5): + +def powerRuleIntegrationFunc(maxCoef=10, maxExp=10, maxTerms=5): numTerms = random.randint(1, maxTerms) problem = "" solution = "" @@ -699,32 +754,33 @@ def powerRuleIntegrationFunc(maxCoef = 10, maxExp = 10, maxTerms = 5): 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 += "(" + str(coefficient) + "/" + str(exponent) + ")x^" + str(exponent + 1) solution = solution + " + c" return problem, solution - -def fourthAngleOfQuadriFunc(maxAngle = 180): + +def fourthAngleOfQuadriFunc(maxAngle=180): angle1 = random.randint(1, maxAngle) - angle2 = random.randint(1, 240-angle1) - angle3 = random.randint(1, 340-(angle1 + angle2)) + 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 - -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) - - solution = str([round((-b+D)/(2*a), 2),round((-b-D)/(2*a), 2)]) - 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) + + solution = str([round((-b + D) / (2 * a), 2), round((-b - D) / (2 * a), 2)]) + return problem, solution def hcfFunc(maxVal=20): @@ -732,15 +788,17 @@ def hcfFunc(maxVal=20): b = random.randint(1, maxVal) x, y = a, b while(y): - x, y = y, x % y + x, y = y, x % y problem = f"HCF of {a} and {b} = " solution = str(x) return problem, solution # || Class Instances -#Format is: -# = Generator("<Title>", <id>, <generalized problem>, <generalized solution>, <function name>) +# Format is: +# <title> = Generator("<Title>", <id>, <generalized problem>, <generalized solution>, <function name>) + + addition = Generator("Addition", 0, "a+b=", "c", additionFunc) subtraction = Generator("Subtraction", 1, "a-b=", "c", subtractionFunc) multiplication = Generator("Multiplication", 2, "a*b=", "c", multiplicationFunc) @@ -749,48 +807,48 @@ binaryComplement1s = Generator("Binary Complement 1s", 4, "1010=", "0101", binar moduloDivision = Generator("Modulo Division", 5, "a%b=", "c", moduloFunc) squareRoot = Generator("Square Root", 6, "sqrt(a)=", "b", squareRootFunc) 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) gcd = Generator("GCD (Greatest Common Denominator)", 10, "GCD of a and b = ", "c", gcdFunc) basicAlgebra = Generator("Basic Algebra", 11, "ax + b = c", "d", basicAlgebraFunc) log = Generator("Logarithm", 12, "log2(8)", "3", logFunc) -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) +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) +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) +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 +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) +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) +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) +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) +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) +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) +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) hcf = Generator("HCF (Highest Common Factor)", 51, "HCF of a and b = ", "c", hcfFunc) diff --git a/tests/test_mathgen.py b/tests/test_mathgen.py index ace72a5..af38bff 100644 --- a/tests/test_mathgen.py +++ b/tests/test_mathgen.py @@ -1,46 +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) +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_addition(maxSum, maxAddend): + assume(maxSum > maxAddend) + problem, solution = addition.func(maxSum, maxAddend) + assert eval(problem[:-1]) == int(solution) + + +@given(maxMinuend=st.integers(min_value=1), maxDiff=st.integers(min_value=1)) +def test_subtraction(maxMinuend, maxDiff): + assume(maxMinuend > maxDiff) + problem, solution = subtraction.func(maxMinuend, maxDiff) + assert eval(problem[:-1]) == int(solution) + + +@given(maxRes=st.integers(min_value=1), maxMulti=st.integers(min_value=1)) +def test_multiplication(maxRes, maxMulti): + assume(maxRes > maxMulti) + problem, solution = multiplication.func(maxRes, maxMulti) + assert eval(problem[:-1]) == int(solution) + + +@given(maxRes=st.integers(min_value=1), maxDivid=st.integers(min_value=1)) +def test_division(maxRes, maxDivid): + assume(maxRes > maxDivid) + problem, solution = division.func(maxRes, maxDivid) + assert eval(problem[:-1]) == float(solution) + + +@given(maxRes=st.integers(min_value=1), maxModulo=st.integers(min_value=1)) +def test_moduloDivision(maxRes, maxModulo): + assume(maxRes > maxModulo) + problem, solution = moduloDivision.func(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_squareRoot(minNo, maxNo): + assume(maxNo > minNo) + problem, solution = squareRoot.func(minNo, maxNo) + assert eval(problem[:-1]) == float(solution)