Split term and sum to 2 functions

mathgenerator/__init__.py

@@ -0,0 +1,23 @@
+genList = []
+
+
+class Generator:
+    def __init__(self, title, id, generalProb, generalSol, func):
+        self.title = title
+        self.id = id
+        self.generalProb = generalProb
+        self.generalSol = generalSol
+        self.func = func
+        genList.append([id, title, self])
+
+    def __str__(self):
+        return str(
+            self.id
+        ) + " " + self.title + " " + self.generalProb + " " + self.generalSol
+
+    def __call__(self, **kwargs):
+        return self.func(**kwargs)
+
+
+def getGenList():
+    return genList

mathgenerator/funcs/BinaryToDecimalFunc.py

@@ -0,0 +1,12 @@
+from .__init__ import *
+
+
+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

mathgenerator/funcs/DecimalToBinaryFunc.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+def DecimalToBinaryFunc(max_dec=99):
+    a = random.randint(1, max_dec)
+    b = bin(a).replace("0b", "")
+
+    problem = "Binary of " + str(a) + "="
+    solution = str(b)
+
+    return problem, solution

mathgenerator/funcs/DiceSumProbFunc.py

@@ -0,0 +1,26 @@
+from .__init__ import *
+
+
+def DiceSumProbFunc(maxDice=3):
+    a = random.randint(1, maxDice)
+    b = random.randint(a, 6 * a)
+
+    count = 0
+    for i in [1, 2, 3, 4, 5, 6]:
+        if a == 1:
+            if i == b:
+                count = count + 1
+        elif a == 2:
+            for j in [1, 2, 3, 4, 5, 6]:
+                if i + j == b:
+                    count = count + 1
+        elif a == 3:
+            for j in [1, 2, 3, 4, 5, 6]:
+                for k in [1, 2, 3, 4, 5, 6]:
+                    if i + j + k == b:
+                        count = count + 1
+
+    problem = "If {} dice are rolled at the same time, the probability of getting a sum of {} =".format(
+        a, b)
+    solution = "{}/{}".format(count, 6**a)
+    return problem, solution

mathgenerator/funcs/MidPointOfTwoPointFunc.py

@@ -0,0 +1,12 @@
+from .__init__ import *
+
+
+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

mathgenerator/funcs/__init__.py

@@ -0,0 +1,86 @@
+import random
+import math
+import fractions
+
+from .addition import *
+from .subtractionFunc import *
+from .multiplicationFunc import *
+from .divisionFunc import *
+from .binaryComplement1sFunc import *
+from .moduloFunc import *
+from .squareRootFunc import *
+from .powerRuleDifferentiationFunc import *
+from .squareFunc import *
+from .gcdFunc import *
+from .lcmFunc import *
+from .basicAlgebraFunc import *
+from .logFunc import *
+from .divisionToIntFunc import *
+from .DecimalToBinaryFunc import *
+from .BinaryToDecimalFunc import *
+from .divideFractionsFunc import *
+from .multiplyIntToMatrix22 import *
+from .areaOfTriangleFunc import *
+from .isTriangleValidFunc import *
+from .MidPointOfTwoPointFunc import *
+from .factoringFunc import *
+from .thirdAngleOfTriangleFunc import *
+from .systemOfEquationsFunc import *
+from .distanceTwoPointsFunc import *
+from .pythagoreanTheoremFunc import *
+from .linearEquationsFunc import *
+from .primeFactorsFunc import *
+from .multiplyFractionsFunc import *
+from .regularPolygonAngleFunc import *
+from .combinationsFunc import *
+from .factorialFunc import *
+from .surfaceAreaCube import *
+from .volumeCube import *
+from .surfaceAreaCuboid import *
+from .volumeCuboid import *
+from .surfaceAreaCylinder import *
+from .volumeCylinder import *
+from .surfaceAreaCone import *
+from .volumeCone import *
+from .commonFactorsFunc import *
+from .intersectionOfTwoLinesFunc import *
+from .permutationFunc import *
+from .vectorCrossFunc import *
+from .compareFractionsFunc import *
+from .simpleInterestFunc import *
+from .matrixMultiplicationFunc import *
+from .cubeRootFunc import *
+from .powerRuleIntegrationFunc import *
+from .fourthAngleOfQuadriFunc import *
+from .quadraticEquation import *
+from .hcfFunc import *
+from .DiceSumProbFunc import *
+from .exponentiationFunc import *
+from .confidenceIntervalFunc import *
+from .surdsComparisonFunc import *
+from .fibonacciSeriesFunc import *
+from .basicTrigonometryFunc import *
+from .sumOfAnglesOfPolygonFunc import *
+from .dataSummaryFunc import *
+from .surfaceAreaSphere import *
+from .volumeSphereFunc import *
+from .nthFibonacciNumberFunc import *
+from .profitLossPercentFunc import *
+from .binaryToHexFunc import *
+from .multiplyComplexNumbersFunc import *
+from .geomProgrFunc import *
+from .geometricMeanFunc import *
+from .harmonicMeanFunc import *
+from .euclidianNormFunc import *
+from .angleBtwVectorsFunc import *
+from .absoluteDifferenceFunc import *
+from .vectorDotFunc import *
+from .binary2sComplement import *
+from .matrixInversion import *
+from .sectorAreaFunc import *
+from .meanMedianFunc import *
+from .determinantToMatrix22 import *
+from .compoundInterestFunc import *
+from .deciToHexaFunc import *
+from .percentageFunc import *
+from .celsiustofahrenheit import *

mathgenerator/funcs/absoluteDifferenceFunc.py

@@ -0,0 +1,12 @@
+from .__init__ import *
+
+
+def absoluteDifferenceFunc(maxA=100, maxB=100):
+    a = random.randint(-1 * maxA, maxA)
+    b = random.randint(-1 * maxB, maxB)
+    absDiff = abs(a - b)
+
+    problem = "Absolute difference between numbers " + \
+        str(a) + " and " + str(b) + " = "
+    solution = absDiff
+    return problem, solution

mathgenerator/funcs/addition.py

@@ -0,0 +1,15 @@
+from .__init__ import *
+from ..__init__ import Generator
+
+
+def additionFunc(maxSum=99, maxAddend=50):
+    a = random.randint(0, 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))
+    c = a + b
+    problem = str(a) + "+" + str(b) + "="
+    solution = str(c)
+    return problem, solution
+
+
+addition = Generator("Addition", 0, "a+b=", "c", additionFunc)

mathgenerator/funcs/angleBtwVectorsFunc.py

@@ -0,0 +1,16 @@
+from .euclidianNormFunc import euclidianNormFunc
+import math
+from .__init__ import *
+
+
+def angleBtwVectorsFunc(v1: list, v2: list):
+    sum = 0
+    for i in v1:
+        for j in v2:
+            sum += i * j
+
+    mags = euclidianNormFunc(v1) * euclidianNormFunc(v2)
+    problem = f"angle between the vectors {v1} and {v2} is:"
+    solution = math.acos(sum / mags)
+    # would return the answer in radians
+    return problem, solution

mathgenerator/funcs/areaOfTriangleFunc.py

@@ -0,0 +1,15 @@
+from .__init__ import *
+
+
+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

mathgenerator/funcs/arithmeticProgressionSumFunc.py

@@ -0,0 +1,12 @@
+from .__init__ import *
+
+def arithmeticProgressionSumFunc (maxd = 100, maxa = 100, maxn = 100):
+    d = random.randint (-1 * maxd, maxd)
+    a1 = random.randint (-1 * maxa, maxa)
+    a2 = a1 + d
+    a3 = a2 + d
+    n = random.randint (4, maxn)
+    apString = str(a1) +', ' + str(a2) +', ' + str(a3) + ' ... '
+    problem = 'Find the sum of first ' + str(n) + ' terms of the AP series: ' + apString
+    solution = n * ((2*a1) + ((n-1)*d))/2
+    return problem, solution

mathgenerator/funcs/arithmeticProgressionTermFunc.py

@@ -0,0 +1,12 @@
+from .__init__ import *
+
+def arithmeticProgressionTermFunc (maxd = 100, maxa = 100, maxn = 100):
+    d = random.randint (-1 * maxd, maxd)
+    a1 = random.randint (-1 * maxa, maxa)
+    a2 = a1 + d
+    a3 = a2 + d
+    n = random.randint (4, maxn)
+    apString = str(a1) +', ' + str(a2) +', ' + str(a3) + ' ... '
+    problem = 'Find the term number ' + str(n) + ' of the AP series: ' + apString
+    solution = a1  + ((n-1)*d)
+    return problen, solution

mathgenerator/funcs/basicAlgebraFunc.py

@@ -0,0 +1,25 @@
+from .__init__ import *
+
+
+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
+        return x
+
+    i = calculate_gcd((c - b), a)
+    x = f"{(c - b)//i}/{a//i}"
+
+    if (c - b == 0):
+        x = "0"
+    elif a == 1 or a == i:
+        x = f"{c - b}"
+
+    problem = f"{a}x + {b} = {c}"
+    solution = x
+    return problem, solution

mathgenerator/funcs/basicTrigonometryFunc.py

@@ -0,0 +1,25 @@
+from .__init__ import *
+
+
+# Handles degrees in quadrant one
+def basicTrigonometryFunc(angles=[0, 30, 45, 60, 90],
+                          functions=["sin", "cos", "tan"]):
+    angle = random.choice(angles)
+    function = random.choice(functions)
+
+    problem = f"What is {function}({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"
+    }
+
+    solution = result_fraction_map[round(eval(expression), 2)] if round(
+        eval(expression), 2) <= 99999 else "∞"  # for handling the ∞ condition
+    return problem, solution

mathgenerator/funcs/binary2sComplement.py

@@ -0,0 +1,28 @@
+from .__init__ import *
+
+
+def binary2sComplementFunc(maxDigits=10):
+    digits = random.randint(1, maxDigits)
+    question = ''.join([str(random.randint(0, 1))
+                        for i in range(digits)]).lstrip('0')
+
+    answer = []
+    for i in question:
+        answer.append(str(int(not bool(int(i)))))
+
+    carry = True
+    j = len(answer) - 1
+    while j >= 0:
+        if answer[j] == '0':
+            answer[j] = '1'
+            carry = False
+            break
+        answer[j] = '0'
+        j -= 1
+
+    if j == 0 and carry is True:
+        answer.insert(0, '1')
+
+    problem = "2's complement of " + question + " ="
+    solution = ''.join(answer).lstrip('0')
+    return problem, solution

mathgenerator/funcs/binaryComplement1sFunc.py

@@ -0,0 +1,15 @@
+from .__init__ import *
+
+
+def binaryComplement1sFunc(maxDigits=10):
+    question = ''
+    answer = ''
+
+    for i in range(random.randint(1, maxDigits)):
+        temp = str(random.randint(0, 1))
+        question += temp
+        answer += "0" if temp == "1" else "1"
+
+    problem = question + "="
+    solution = answer
+    return problem, solution

mathgenerator/funcs/binaryToHexFunc.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+def binaryToHexFunc(max_dig=10):
+    problem = ''
+    for i in range(random.randint(1, max_dig)):
+        temp = str(random.randint(0, 1))
+        problem += temp
+
+    solution = hex(int(problem, 2))
+    return problem, solution

mathgenerator/funcs/celsiustofahrenheit.py

@@ -0,0 +1,14 @@
+from .__init__ import *
+from ..__init__ import Generator
+
+
+def celsiustofahrenheitFunc(maxTemp=100):
+    celsius = random.randint(-50, maxTemp)
+    fahrenheit = (celsius * (9 / 5)) + 32
+    problem = "Convert " + str(celsius) + " degrees Celsius to degrees Fahrenheit ="
+    solution = str(fahrenheit)
+    return problem, solution
+
+
+celsiustofahrenheit = Generator("Celsius To Fahrenheit", 81,
+                                "(C +(9/5))+32=", "F", celsiustofahrenheitFunc)

mathgenerator/funcs/combinationsFunc.py

@@ -0,0 +1,19 @@
+from .__init__ import *
+
+
+def combinationsFunc(maxlength=20):
+    def factorial(a):
+        d = 1
+        for i in range(a):
+            a = (i + 1) * d
+            d = a
+        return d
+
+    a = random.randint(10, maxlength)
+    b = random.randint(0, 9)
+
+    solution = int(factorial(a) / (factorial(b) * factorial(a - b)))
+    problem = "Number of combinations from {} objects picked {} at a time ".format(
+        a, b)
+
+    return problem, solution

mathgenerator/funcs/commonFactorsFunc.py

@@ -0,0 +1,24 @@
+from .__init__ import *
+
+
+def commonFactorsFunc(maxVal=100):
+    a = x = random.randint(1, maxVal)
+    b = y = random.randint(1, maxVal)
+
+    if (x < y):
+        min = x
+    else:
+        min = y
+
+    count = 0
+    arr = []
+
+    for i in range(1, min + 1):
+        if (x % i == 0):
+            if (y % i == 0):
+                count = count + 1
+                arr.append(i)
+
+    problem = f"Common Factors of {a} and {b} = "
+    solution = arr
+    return problem, solution

mathgenerator/funcs/compareFractionsFunc.py

@@ -0,0 +1,26 @@
+from .__init__ import *
+
+
+def compareFractionsFunc(maxVal=10):
+    a = random.randint(1, maxVal)
+    b = random.randint(1, maxVal)
+    c = random.randint(1, maxVal)
+    d = random.randint(1, maxVal)
+
+    while (a == b):
+        b = random.randint(1, maxVal)
+    while (c == d):
+        d = random.randint(1, maxVal)
+
+    first = a / b
+    second = c / d
+
+    if (first > second):
+        solution = ">"
+    elif (first < second):
+        solution = "<"
+    else:
+        solution = "="
+
+    problem = f"Which symbol represents the comparison between {a}/{b} and {c}/{d}?"
+    return problem, solution

mathgenerator/funcs/compoundInterestFunc.py

@@ -0,0 +1,18 @@
+from .__init__ import *
+
+
+def compoundInterestFunc(maxPrinciple=10000,
+                         maxRate=10,
+                         maxTime=10,
+                         maxPeriod=10):
+    p = random.randint(100, maxPrinciple)
+    r = random.randint(1, maxRate)
+    t = random.randint(1, maxTime)
+    n = random.randint(1, maxPeriod)
+    A = p * ((1 + (r / (100 * n))**(n * t)))
+    problem = "Compound Interest for a principle amount of " + str(
+        p) + " dollars, " + str(
+            r) + "% rate of interest and for a time period of " + str(
+                t) + " compounded monthly is = "
+    solution = round(A, 2)
+    return problem, solution

mathgenerator/funcs/confidenceIntervalFunc.py

@@ -0,0 +1,31 @@
+from .__init__ import *
+
+
+def confidenceIntervalFunc():
+    n = random.randint(20, 40)
+    j = random.randint(0, 3)
+
+    lst = random.sample(range(200, 300), n)
+    lst_per = [80, 90, 95, 99]
+    lst_t = [1.282, 1.645, 1.960, 2.576]
+
+    mean = 0
+    sd = 0
+
+    for i in lst:
+        count = i + mean
+        mean = count
+
+    mean = mean / n
+
+    for i in lst:
+        x = (i - mean)**2 + sd
+        sd = x
+
+    sd = sd / n
+    standard_error = lst_t[j] * math.sqrt(sd / n)
+
+    problem = 'The confidence interval for sample {} with {}% confidence is'.format(
+        [x for x in lst], lst_per[j])
+    solution = '({}, {})'.format(mean + standard_error, mean - standard_error)
+    return problem, solution

mathgenerator/funcs/cubeRootFunc.py

@@ -0,0 +1,10 @@
+from .__init__ import *
+
+
+def cubeRootFunc(minNo=1, maxNo=1000):
+    b = random.randint(minNo, maxNo)
+    a = b**(1 / 3)
+
+    problem = "cuberoot of " + str(b) + " upto 2 decimal places is:"
+    solution = str(round(a, 2))
+    return problem, solution

mathgenerator/funcs/dataSummaryFunc.py

@@ -0,0 +1,28 @@
+from .__init__ import *
+
+
+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
+
+    # we're printing stuff here?
+    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

mathgenerator/funcs/deciToHexaFunc.py

@@ -0,0 +1,10 @@
+from .__init__ import *
+
+
+def deciToHexaFunc(max_dec=1000):
+    a = random.randint(0, max_dec)
+    b = hex(a)
+    problem = "Binary of " + str(a) + "="
+    solution = str(b)
+
+    return problem, solution

mathgenerator/funcs/determinantToMatrix22.py

@@ -0,0 +1,13 @@
+from .__init__ import *
+
+
+def determinantToMatrix22(maxMatrixVal=100):
+    a = random.randint(0, maxMatrixVal)
+    b = random.randint(0, maxMatrixVal)
+    c = random.randint(0, maxMatrixVal)
+    d = random.randint(0, maxMatrixVal)
+
+    determinant = a * d - b * c
+    problem = f"Det([[{a}, {b}], [{c}, {d}]]) = "
+    solution = f" {determinant}"
+    return problem, solution

mathgenerator/funcs/distanceTwoPointsFunc.py

@@ -0,0 +1,14 @@
+from .__init__ import *
+
+
+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

mathgenerator/funcs/divideFractionsFunc.py

@@ -0,0 +1,32 @@
+from .__init__ import *
+
+
+def divideFractionsFunc(maxVal=10):
+    a = random.randint(1, maxVal)
+    b = random.randint(1, maxVal)
+
+    while (a == b):
+        b = random.randint(1, maxVal)
+
+    c = random.randint(1, maxVal)
+    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
+        return x
+
+    tmp_n = a * d
+    tmp_d = b * c
+
+    gcd = calculate_gcd(tmp_n, tmp_d)
+    x = f"{tmp_n//gcd}/{tmp_d//gcd}"
+
+    if (tmp_d == 1 or tmp_d == gcd):
+        x = f"{tmp_n//gcd}"
+    # for equal numerator and denominators
+    problem = f"({a}/{b})/({c}/{d})"
+    solution = x
+    return problem, solution

mathgenerator/funcs/divisionFunc.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+def divisionFunc(maxRes=99, maxDivid=99):
+    a = random.randint(0, maxDivid)
+    b = random.randint(0, min(maxRes, maxDivid))
+    c = a / b
+
+    problem = str(a) + "/" + str(b) + "="
+    solution = str(c)
+    return problem, solution

mathgenerator/funcs/divisionToIntFunc.py

@@ -0,0 +1,13 @@
+from .__init__ import *
+
+
+def divisionToIntFunc(maxA=25, maxB=25):
+    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

mathgenerator/funcs/euclidianNormFunc.py

@@ -0,0 +1,7 @@
+from .__init__ import *
+
+
+def euclidianNormFunc(v1: list):
+    problem = f"Euclidian norm or L2 norm of the vector{v1} is:"
+    solution = sqrt(sum([i**2 for i in v1]))
+    return problem, solution

mathgenerator/funcs/exponentiationFunc.py

@@ -0,0 +1,10 @@
+from .__init__ import *
+
+
+def exponentiationFunc(maxBase=20, maxExpo=10):
+    base = random.randint(1, maxBase)
+    expo = random.randint(1, maxExpo)
+
+    problem = f"{base}^{expo} ="
+    solution = str(base**expo)
+    return problem, solution

mathgenerator/funcs/factorialFunc.py

@@ -0,0 +1,15 @@
+from .__init__ import *
+
+
+def factorialFunc(maxInput=6):
+    a = random.randint(0, maxInput)
+    n = a
+
+    problem = str(a) + "! = "
+    b = 1
+
+    while a != 1 and n > 0:
+        b *= n
+        n -= 1
+    solution = str(b)
+    return problem, solution

mathgenerator/funcs/factoringFunc.py

@@ -0,0 +1,29 @@
+from .__init__ import *
+
+
+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

mathgenerator/funcs/fibonacciSeriesFunc.py

@@ -0,0 +1,21 @@
+from .__init__ import *
+
+
+def fibonacciSeriesFunc(minNo=1):
+    n = random.randint(minNo, 20)
+
+    def createFibList(n):
+        list = []
+        for i in range(n):
+            if i < 2:
+                list.append(i)
+            else:
+                val = list[i - 1] + list[i - 2]
+                list.append(val)
+        return list
+
+    fibList = createFibList(n)
+
+    problem = "The Fibonacci Series of the first " + str(n) + " numbers is ?"
+    solution = fibList
+    return problem, solution

mathgenerator/funcs/fourthAngleOfQuadriFunc.py

@@ -0,0 +1,14 @@
+from .__init__ import *
+
+
+def fourthAngleOfQuadriFunc(maxAngle=180):
+    angle1 = random.randint(1, maxAngle)
+    angle2 = random.randint(1, 240 - angle1)
+    angle3 = random.randint(1, 340 - (angle1 + angle2))
+
+    sum_ = angle1 + angle2 + angle3
+    angle4 = 360 - sum_
+
+    problem = f"Fourth angle of quadrilateral with angles {angle1} , {angle2}, {angle3} ="
+    solution = angle4
+    return problem, solution

mathgenerator/funcs/gcdFunc.py

@@ -0,0 +1,12 @@
+from .__init__ import *
+
+
+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
+    problem = f"GCD of {a} and {b} = "
+    solution = str(x)
+    return problem, solution

mathgenerator/funcs/geomProgrFunc.py

@@ -0,0 +1,23 @@
+from .__init__ import *
+
+
+def geomProgrFunc(number_values=6,
+                  min_value=2,
+                  max_value=12,
+                  n_term=7,
+                  sum_term=5):
+    r = random.randint(min_value, max_value)
+    a = random.randint(min_value, max_value)
+    n_term = random.randint(number_values, number_values + 5)
+    sum_term = random.randint(number_values, number_values + 5)
+    GP = []
+    for i in range(number_values):
+        GP.append(a * (r**i))
+    problem = "For the given GP " + str(
+        GP) + " ,Find the value of a,common ratio," + str(
+            n_term) + "th term value, sum upto " + str(sum_term) + "th term"
+    value_nth_term = a * (r**(n_term - 1))
+    sum_till_nth_term = a * ((r**sum_term - 1) / (r - 1))
+    solution = "The value of a is {}, common ratio is {} , {}th term is {} , sum upto {}th term is {}".format(
+        a, r, n_term, value_nth_term, sum_term, sum_till_nth_term)
+    return problem, solution

mathgenerator/funcs/geometricMeanFunc.py

@@ -0,0 +1,27 @@
+from .__init__ import *
+
+
+def geometricMeanFunc(maxValue=100, maxNum=4):
+    a = random.randint(1, maxValue)
+    b = random.randint(1, maxValue)
+    c = random.randint(1, maxValue)
+    d = random.randint(1, maxValue)
+    num = random.randint(2, 4)
+    if num == 2:
+        product = a * b
+    elif num == 3:
+        product = a * b * c
+    elif num == 4:
+        product = a * b * c * d
+
+    ans = product**(1 / num)
+    if num == 2:
+        problem = f"Geometric mean of {num} numbers {a} and {b} = "
+        solution = f"({a}*{b})^(1/{num}) = {ans}"
+    elif num == 3:
+        problem = f"Geometric mean of {num} numbers {a} , {b} and {c} = "
+        solution = f"({a}*{b}*{c})^(1/{num}) = {ans}"
+    elif num == 4:
+        problem = f"Geometric mean of {num} numbers {a} , {b} , {c} , {d} = "
+        solution = f"({a}*{b}*{c}*{d})^(1/{num}) = {ans}"
+    return problem, solution

mathgenerator/funcs/harmonicMeanFunc.py

@@ -0,0 +1,28 @@
+from .__init__ import *
+
+
+def harmonicMeanFunc(maxValue=100, maxNum=4):
+
+    a = random.randint(1, maxValue)
+    b = random.randint(1, maxValue)
+    c = random.randint(1, maxValue)
+    d = random.randint(1, maxValue)
+    num = random.randint(2, 4)
+    if num == 2:
+        sum = (1 / a) + (1 / b)
+    elif num == 3:
+        sum = (1 / a) + (1 / b) + (1 / c)
+    elif num == 4:
+        sum = (1 / a) + (1 / b) + (1 / c) + (1 / d)
+
+    ans = num / sum
+    if num == 2:
+        problem = f"Harmonic mean of {num} numbers {a} and {b} = "
+        solution = f" {num}/((1/{a}) + (1/{b})) = {ans}"
+    elif num == 3:
+        problem = f"Harmonic mean of {num} numbers {a} , {b} and {c} = "
+        solution = f" {num}/((1/{a}) + (1/{b}) + (1/{c})) = {ans}"
+    elif num == 4:
+        problem = f"Harmonic mean of {num} numbers {a} , {b} , {c} , {d} = "
+        solution = f" {num}/((1/{a}) + (1/{b}) + (1/{c}) + (1/{d})) = {ans}"
+    return problem, solution

mathgenerator/funcs/hcfFunc.py

@@ -0,0 +1,12 @@
+from .__init__ import *
+
+
+def hcfFunc(maxVal=20):
+    a = random.randint(1, maxVal)
+    b = random.randint(1, maxVal)
+    x, y = a, b
+    while (y):
+        x, y = y, x % y
+    problem = f"HCF of {a} and {b} = "
+    solution = str(x)
+    return problem, solution

mathgenerator/funcs/intersectionOfTwoLinesFunc.py

@@ -0,0 +1,66 @@
+from .__init__ import *
+
+
+def intersectionOfTwoLinesFunc(minM=-10,
+                               maxM=10,
+                               minB=-10,
+                               maxB=10,
+                               minDenominator=1,
+                               maxDenominator=6):
+    def generateEquationString(m, b):
+        """
+        Generates an equation given the slope and intercept.
+        It handles cases where m is fractional.
+        It also ensures that we don't have weird signs such as y = mx + -b.
+        """
+        if m[1] == 1:
+            m = m[0]
+        else:
+            m = f"{m[0]}/{m[1]}"
+        base = f"y = {m}x"
+        if b > 0:
+            return f"{base} + {b}"
+        elif b < 0:
+            return f"{base} - {b * -1}"
+        else:
+            return base
+
+    def fractionToString(x):
+        """
+        Converts the given fractions.Fraction into a string.
+        """
+        if x.denominator == 1:
+            x = x.numerator
+        else:
+            x = f"{x.numerator}/{x.denominator}"
+        return x
+
+    m1 = (random.randint(minM,
+                         maxM), random.randint(minDenominator, maxDenominator))
+    m2 = (random.randint(minM,
+                         maxM), random.randint(minDenominator, maxDenominator))
+
+    b1 = random.randint(minB, maxB)
+    b2 = random.randint(minB, maxB)
+
+    equation1 = generateEquationString(m1, b1)
+    equation2 = generateEquationString(m2, b2)
+
+    problem = "Find the point of intersection of the two lines: "
+    problem += f"{equation1} and {equation2}"
+
+    m1 = fractions.Fraction(*m1)
+    m2 = fractions.Fraction(*m2)
+    # if m1 == m2 then the slopes are equal
+    # This can happen if both line are the same
+    # Or if they are parallel
+    # In either case there is no intersection
+
+    if m1 == m2:
+        solution = "No Solution"
+    else:
+        intersection_x = (b1 - b2) / (m2 - m1)
+        intersection_y = ((m2 * b1) - (m1 * b2)) / (m2 - m1)
+        solution = f"({fractionToString(intersection_x)}, {fractionToString(intersection_y)})"
+
+    return problem, solution

mathgenerator/funcs/isTriangleValidFunc.py

@@ -0,0 +1,20 @@
+from .__init__ import *
+
+
+def isTriangleValidFunc(maxSideLength=50):
+    sideA = random.randint(1, maxSideLength)
+    sideB = random.randint(1, maxSideLength)
+    sideC = random.randint(1, maxSideLength)
+
+    sideSums = [sideA + sideB, sideB + sideC, sideC + sideA]
+    sides = [sideC, sideA, sideB]
+
+    exists = True & (sides[0] < sideSums[0]) & (sides[1] < sideSums[1]) & (
+        sides[2] < sideSums[2])
+    problem = f"Does triangle with sides {sideA}, {sideB} and {sideC} exist?"
+
+    if exists:
+        solution = "Yes"
+        return problem, solution
+    solution = "No"
+    return problem, solution

mathgenerator/funcs/lcmFunc.py

@@ -0,0 +1,17 @@
+from .__init__ import *
+
+
+def lcmFunc(maxVal=20):
+    a = random.randint(1, maxVal)
+    b = random.randint(1, maxVal)
+    c = a * b
+    x, y = a, b
+
+    while y:
+        x, y = y, x % y
+    d = c // x
+
+    problem = f"LCM of {a} and {b} ="
+    solution = str(d)
+
+    return problem, solution

mathgenerator/funcs/linearEquationsFunc.py

@@ -0,0 +1,29 @@
+from .__init__ import *
+
+
+def linearEquationsFunc(n=2, varRange=20, coeffRange=20):
+    if n > 10:
+        print("[!] n cannot be greater than 10")
+        return None, None
+
+    vars = ['x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g'][:n]
+    soln = [random.randint(-varRange, varRange) for i in range(n)]
+    problem = list()
+    solution = ", ".join(
+        ["{} = {}".format(vars[i], soln[i]) for i in range(n)])
+
+    for _ in range(n):
+        coeff = [random.randint(-coeffRange, coeffRange) for i in range(n)]
+        res = sum([coeff[i] * soln[i] for i in range(n)])
+        prob = [
+            "{}{}".format(coeff[i], vars[i]) if coeff[i] != 0 else ""
+            for i in range(n)
+        ]
+
+        while "" in prob:
+            prob.remove("")
+        prob = " + ".join(prob) + " = " + str(res)
+        problem.append(prob)
+
+    problem = "\n".join(problem)
+    return problem, solution

mathgenerator/funcs/logFunc.py

@@ -0,0 +1,12 @@
+from .__init__ import *
+
+
+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) + ")"
+    solution = str(a)
+
+    return problem, solution

mathgenerator/funcs/matrixInversion.py

@@ -0,0 +1,78 @@
+from .__init__ import *
+import sympy
+
+
+def matrixInversion(SquareMatrixDimension=3,
+                    MaxMatrixElement=99,
+                    OnlyIntegerElementsInInvertedMatrix=False):
+    if OnlyIntegerElementsInInvertedMatrix is True:
+        isItOk = False
+        Mat = list()
+        while (isItOk is False):
+            Mat = list()
+            for i in range(0, SquareMatrixDimension):
+                z = list()
+                for j in range(0, SquareMatrixDimension):
+                    z.append(0)
+                z[i] = 1
+                Mat.append(z)
+            MaxAllowedMatrixElement = math.ceil(
+                pow(MaxMatrixElement, 1 / (SquareMatrixDimension)))
+            randomlist = random.sample(range(0, MaxAllowedMatrixElement + 1),
+                                       SquareMatrixDimension)
+
+            for i in range(0, SquareMatrixDimension):
+                if i == SquareMatrixDimension - 1:
+                    Mat[0] = [
+                        j + (k * randomlist[i])
+                        for j, k in zip(Mat[0], Mat[i])
+                    ]
+                else:
+                    Mat[i + 1] = [
+                        j + (k * randomlist[i])
+                        for j, k in zip(Mat[i + 1], Mat[i])
+                    ]
+
+            for i in range(1, SquareMatrixDimension - 1):
+                Mat[i] = [
+                    sum(i) for i in zip(Mat[SquareMatrixDimension - 1], Mat[i])
+                ]
+
+            isItOk = True
+            for i in Mat:
+                for j in i:
+                    if j > MaxMatrixElement:
+                        isItOk = False
+                        break
+                if isItOk is False:
+                    break
+
+        random.shuffle(Mat)
+        Mat = sympy.Matrix(Mat)
+        Mat = sympy.Matrix.transpose(Mat)
+        Mat = Mat.tolist()
+        random.shuffle(Mat)
+        Mat = sympy.Matrix(Mat)
+        Mat = sympy.Matrix.transpose(Mat)
+
+    else:
+        randomlist = list(sympy.primerange(0, MaxMatrixElement + 1))
+        plist = random.sample(randomlist, SquareMatrixDimension)
+        randomlist = random.sample(
+            range(0, MaxMatrixElement + 1),
+            SquareMatrixDimension * SquareMatrixDimension)
+        randomlist = list(set(randomlist) - set(plist))
+        n_list = random.sample(
+            randomlist, SquareMatrixDimension * (SquareMatrixDimension - 1))
+        Mat = list()
+        for i in range(0, SquareMatrixDimension):
+            z = list()
+            z.append(plist[i])
+            for j in range(0, SquareMatrixDimension - 1):
+                z.append(n_list[(i * SquareMatrixDimension) + j - i])
+            random.shuffle(z)
+            Mat.append(z)
+        Mat = sympy.Matrix(Mat)
+    problem = 'Inverse of Matrix ' + str(Mat) + ' is:'
+    solution = str(sympy.Matrix.inv(Mat))
+    return problem, solution

mathgenerator/funcs/matrixMultiplicationFunc.py

@@ -0,0 +1,53 @@
+from .__init__ import *
+
+
+def matrixMultiplicationFunc(maxVal=100):
+    m = random.randint(2, 10)
+    n = random.randint(2, 10)
+    k = random.randint(2, 10)
+
+    # generate matrices a and b
+    a = []
+    for r in range(m):
+        a.append([])
+        for c in range(n):
+            a[r].append(random.randint(-maxVal, maxVal))
+    b = []
+    for r in range(n):
+        b.append([])
+        for c in range(k):
+            b[r].append(random.randint(-maxVal, maxVal))
+
+    res = []
+    a_string = matrixMultiplicationFuncHelper(a)
+    b_string = matrixMultiplicationFuncHelper(b)
+
+    for r in range(m):
+        res.append([])
+
+        for c in range(k):
+            temp = 0
+
+            for t in range(n):
+                temp += a[r][t] * b[t][c]
+            res[r].append(temp)
+
+    # 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}"
+    solution = matrixMultiplicationFuncHelper(res)
+    return problem, solution
+
+
+def matrixMultiplicationFuncHelper(inp):
+    m = len(inp)
+    n = len(inp[0])
+
+    string = "[["
+    for i in range(m):
+        for j in range(n):
+            string += f"{inp[i][j]: 6d}"
+            string += ", " if j < n - 1 else ""
+        string += "]\n [" if i < m - 1 else ""
+    string += "]]"
+
+    return string

mathgenerator/funcs/meanMedianFunc.py

@@ -0,0 +1,14 @@
+from .__init__ import *
+
+
+def meanMedianFunc(maxlen=10):
+    randomlist = random.sample(range(1, 99), maxlen)
+    total = 0
+    for n in randomlist:
+        total = total + n
+    mean = total / 10
+    problem = f"Given the series of numbers {randomlist}. find the arithmatic mean and mdian of the series"
+    randomlist.sort()
+    median = (randomlist[4] + randomlist[5]) / 2
+    solution = f"Arithmetic mean of the series is {mean} and Arithmetic median of this series is {median}"
+    return problem, solution

mathgenerator/funcs/moduloFunc.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+def moduloFunc(maxRes=99, maxModulo=99):
+    a = random.randint(0, maxModulo)
+    b = random.randint(0, min(maxRes, maxModulo))
+    c = a % b if b != 0 else 0
+
+    problem = str(a) + "%" + str(b) + "="
+    solution = str(c)
+    return problem, solution

mathgenerator/funcs/multiplicationFunc.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+def multiplicationFunc(maxRes=99, maxMulti=99):
+    a = random.randint(0, maxMulti)
+    b = random.randint(0, min(int(maxMulti / a), maxRes))
+    c = a * b
+
+    problem = str(a) + "*" + str(b) + "="
+    solution = str(c)
+    return problem, solution

mathgenerator/funcs/multiplyComplexNumbersFunc.py

@@ -0,0 +1,12 @@
+from .__init__ import *
+
+
+def multiplyComplexNumbersFunc(minRealImaginaryNum=-20,
+                               maxRealImaginaryNum=20):
+    num1 = complex(random.randint(minRealImaginaryNum, maxRealImaginaryNum),
+                   random.randint(minRealImaginaryNum, maxRealImaginaryNum))
+    num2 = complex(random.randint(minRealImaginaryNum, maxRealImaginaryNum),
+                   random.randint(minRealImaginaryNum, maxRealImaginaryNum))
+    problem = f"{num1} * {num2} = "
+    solution = num1 * num2
+    return problem, solution

mathgenerator/funcs/multiplyFractionsFunc.py

@@ -0,0 +1,32 @@
+from .__init__ import *
+
+
+def multiplyFractionsFunc(maxVal=10):
+    a = random.randint(1, maxVal)
+    b = random.randint(1, maxVal)
+    c = random.randint(1, maxVal)
+    d = random.randint(1, maxVal)
+
+    while (a == b):
+        b = random.randint(1, maxVal)
+
+    while (c == d):
+        d = random.randint(1, maxVal)
+
+    def calculate_gcd(x, y):
+        while (y):
+            x, y = y, x % y
+        return x
+
+    tmp_n = a * c
+    tmp_d = b * d
+
+    gcd = calculate_gcd(tmp_n, tmp_d)
+    x = f"{tmp_n//gcd}/{tmp_d//gcd}"
+
+    if (tmp_d == 1 or tmp_d == gcd):
+        x = f"{tmp_n//gcd}"
+
+    problem = f"({a}/{b})*({c}/{d})"
+    solution = x
+    return problem, solution

mathgenerator/funcs/multiplyIntToMatrix22.py

@@ -0,0 +1,13 @@
+from .__init__ import *
+
+
+def multiplyIntToMatrix22(maxMatrixVal=10, maxRes=100):
+    a = random.randint(0, maxMatrixVal)
+    b = random.randint(0, maxMatrixVal)
+    c = random.randint(0, maxMatrixVal)
+    d = random.randint(0, maxMatrixVal)
+
+    constant = random.randint(0, int(maxRes / max(a, b, c, d)))
+    problem = f"{constant} * [[{a}, {b}], [{c}, {d}]] = "
+    solution = f"[[{a*constant},{b*constant}],[{c*constant},{d*constant}]]"
+    return problem, solution

mathgenerator/funcs/nthFibonacciNumberFunc.py

@@ -0,0 +1,10 @@
+from .__init__ import *
+
+
+def nthFibonacciNumberFunc(maxN=100):
+    golden_ratio = (1 + math.sqrt(5)) / 2
+    n = random.randint(1, maxN)
+    problem = f"What is the {n}th Fibonacci number?"
+    ans = round((math.pow(golden_ratio, n) - math.pow(-golden_ratio, -n)) / (math.sqrt(5)))
+    solution = f"{ans}"
+    return problem, solution

mathgenerator/funcs/percentageFunc.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+def percentageFunc(maxValue=99, maxpercentage=99):
+    a = random.randint(1, maxpercentage)
+    b = random.randint(1, maxValue)
+    problem = f"What is {a}% of {b}?"
+    percentage = a / 100 * b
+    formatted_float = "{:.2f}".format(percentage)
+    solution = f"Required percentage = {formatted_float}%"
+    return problem, solution

mathgenerator/funcs/permutationFunc.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+def permutationFunc(maxlength=20):
+    a = random.randint(10, maxlength)
+    b = random.randint(0, 9)
+
+    solution = int(math.factorial(a) / (math.factorial(a - b)))
+    problem = "Number of Permutations from {} objects picked {} at a time =  ".format(
+        a, b)
+    return problem, solution

mathgenerator/funcs/powerRuleDifferentiationFunc.py

@@ -0,0 +1,18 @@
+from .__init__ import *
+
+
+def powerRuleDifferentiationFunc(maxCoef=10, maxExp=10, maxTerms=5):
+    numTerms = random.randint(1, maxTerms)
+    problem = ""
+    solution = ""
+
+    for i in range(numTerms):
+        if i > 0:
+            problem += " + "
+            solution += " + "
+        coefficient = random.randint(1, maxCoef)
+        exponent = random.randint(1, maxExp)
+
+        problem += str(coefficient) + "x^" + str(exponent)
+        solution += str(coefficient * exponent) + "x^" + str(exponent - 1)
+    return problem, solution

mathgenerator/funcs/powerRuleIntegrationFunc.py

@@ -0,0 +1,21 @@
+from .__init__ import *
+
+
+def powerRuleIntegrationFunc(maxCoef=10, maxExp=10, maxTerms=5):
+    numTerms = random.randint(1, maxTerms)
+    problem = ""
+    solution = ""
+
+    for i in range(numTerms):
+        if i > 0:
+            problem += " + "
+            solution += " + "
+        coefficient = random.randint(1, maxCoef)
+        exponent = random.randint(1, maxExp)
+
+        problem += str(coefficient) + "x^" + str(exponent)
+        solution += "(" + str(coefficient) + "/" + \
+            str(exponent) + ")x^" + str(exponent + 1)
+
+    solution += " + c"
+    return problem, solution

mathgenerator/funcs/primeFactorsFunc.py

@@ -0,0 +1,22 @@
+from .__init__ import *
+
+
+def primeFactorsFunc(minVal=1, maxVal=200):
+    a = random.randint(minVal, maxVal)
+    n = a
+    i = 2
+    factors = []
+
+    while i * i <= n:
+        if n % i:
+            i += 1
+        else:
+            n //= i
+            factors.append(i)
+
+    if n > 1:
+        factors.append(n)
+
+    problem = f"Find prime factors of {a}"
+    solution = f"{factors}"
+    return problem, solution

mathgenerator/funcs/profitLossPercentFunc.py

@@ -0,0 +1,16 @@
+from .__init__ import *
+
+
+def profitLossPercentFunc(maxCP=1000, maxSP=1000):
+    cP = random.randint(1, maxCP)
+    sP = random.randint(1, maxSP)
+    diff = abs(sP - cP)
+    if (sP - cP >= 0):
+        profitOrLoss = "Profit"
+    else:
+        profitOrLoss = "Loss"
+    percent = diff / cP * 100
+    problem = f"{profitOrLoss} percent when CP = {cP} and SP = {sP} is: "
+    solution = percent
+
+    return problem, solution

mathgenerator/funcs/pythagoreanTheoremFunc.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+def pythagoreanTheoremFunc(maxLength=20):
+    a = random.randint(1, maxLength)
+    b = random.randint(1, maxLength)
+    c = (a**2 + b**2)**0.5
+
+    problem = f"The hypotenuse of a right triangle given the other two lengths {a} and {b} = "
+    solution = f"{c:.0f}" if c.is_integer() else f"{c:.2f}"
+    return problem, solution

mathgenerator/funcs/quadraticEquation.py

@@ -0,0 +1,15 @@
+from .__init__ import *
+
+
+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

mathgenerator/funcs/regularPolygonAngleFunc.py

@@ -0,0 +1,10 @@
+from .__init__ import *
+
+
+def regularPolygonAngleFunc(minVal=3, maxVal=20):
+    sideNum = random.randint(minVal, maxVal)
+    problem = f"Find the angle of a regular polygon with {sideNum} sides"
+
+    exteriorAngle = round((360 / sideNum), 2)
+    solution = 180 - exteriorAngle
+    return problem, solution

mathgenerator/funcs/sectorAreaFunc.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+def sectorAreaFunc(maxRadius=49, maxAngle=359):
+    Radius = random.randint(1, maxRadius)
+    Angle = random.randint(1, maxAngle)
+    problem = f"Given radius, {Radius} and angle, {Angle}. Find the area of the sector."
+    secArea = float((Angle / 360) * math.pi * Radius * Radius)
+    formatted_float = "{:.5f}".format(secArea)
+    solution = f"Area of sector = {formatted_float}"
+    return problem, solution

mathgenerator/funcs/simpleInterestFunc.py

@@ -0,0 +1,15 @@
+from .__init__ import *
+
+
+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

mathgenerator/funcs/squareFunc.py

@@ -0,0 +1,10 @@
+from .__init__ import *
+
+
+def squareFunc(maxSquareNum=20):
+    a = random.randint(1, maxSquareNum)
+    b = a * a
+
+    problem = str(a) + "^2" + "="
+    solution = str(b)
+    return problem, solution

mathgenerator/funcs/squareRootFunc.py

@@ -0,0 +1,10 @@
+from .__init__ import *
+
+
+def squareRootFunc(minNo=1, maxNo=12):
+    b = random.randint(minNo, maxNo)
+    a = b * b
+
+    problem = "sqrt(" + str(a) + ")="
+    solution = str(b)
+    return problem, solution

mathgenerator/funcs/subtractionFunc.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+def subtractionFunc(maxMinuend=99, maxDiff=99):
+    a = random.randint(0, maxMinuend)
+    b = random.randint(max(0, (a - maxDiff)), a)
+    c = a - b
+
+    problem = str(a) + "-" + str(b) + "="
+    solution = str(c)
+    return problem, solution

mathgenerator/funcs/sumOfAnglesOfPolygonFunc.py

@@ -0,0 +1,10 @@
+from .__init__ import *
+
+
+def sumOfAnglesOfPolygonFunc(maxSides=12):
+    side = random.randint(3, maxSides)
+    sum = (side - 2) * 180
+
+    problem = f"Sum of angles of polygon with {side} sides = "
+    solution = sum
+    return problem, solution

mathgenerator/funcs/surdsComparisonFunc.py

@@ -0,0 +1,17 @@
+from .__init__ import *
+
+
+def surdsComparisonFunc(maxValue=100, maxRoot=10):
+    radicand1, radicand2 = tuple(random.sample(range(1, maxValue), 2))
+    degree1, degree2 = tuple(random.sample(range(1, maxRoot), 2))
+
+    problem = f"Fill in the blanks {radicand1}^(1/{degree1}) _ {radicand2}^(1/{degree2})"
+    first = math.pow(radicand1, 1 / degree1)
+    second = math.pow(radicand2, 1 / degree2)
+
+    solution = "="
+    if first > second:
+        solution = ">"
+    elif first < second:
+        solution = "<"
+    return problem, solution

mathgenerator/funcs/surfaceAreaCone.py

@@ -0,0 +1,13 @@
+from .__init__ import *
+
+
+def surfaceAreaCone(maxRadius=20, maxHeight=50, unit='m'):
+    a = random.randint(1, maxHeight)
+    b = random.randint(1, maxRadius)
+
+    slopingHeight = math.sqrt(a**2 + b**2)
+    problem = f"Surface area of cone with height = {a}{unit} and radius = {b}{unit} is"
+    ans = int(math.pi * b * slopingHeight + math.pi * b * b)
+
+    solution = f"{ans} {unit}^2"
+    return problem, solution

mathgenerator/funcs/surfaceAreaCube.py

@@ -0,0 +1,9 @@
+from .__init__ import *
+
+
+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

mathgenerator/funcs/surfaceAreaCuboid.py

@@ -0,0 +1,12 @@
+from .__init__ import *
+
+
+def surfaceAreaCuboid(maxSide=20, unit='m'):
+    a = random.randint(1, maxSide)
+    b = random.randint(1, maxSide)
+    c = random.randint(1, maxSide)
+
+    problem = f"Surface area of cuboid with sides = {a}{unit}, {b}{unit}, {c}{unit} is"
+    ans = 2 * (a * b + b * c + c * a)
+    solution = f"{ans} {unit}^2"
+    return problem, solution

mathgenerator/funcs/surfaceAreaCylinder.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+def surfaceAreaCylinder(maxRadius=20, maxHeight=50, unit='m'):
+    a = random.randint(1, maxHeight)
+    b = random.randint(1, maxRadius)
+
+    problem = f"Surface area of cylinder with height = {a}{unit} and radius = {b}{unit} is"
+    ans = int(2 * math.pi * a * b + 2 * math.pi * b * b)
+    solution = f"{ans} {unit}^2"
+    return problem, solution

mathgenerator/funcs/surfaceAreaSphere.py

@@ -0,0 +1,10 @@
+from .__init__ import *
+
+
+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

mathgenerator/funcs/systemOfEquationsFunc.py

@@ -0,0 +1,47 @@
+from .__init__ import *
+
+
+def systemOfEquationsFunc(range_x=10, range_y=10, coeff_mult_range=10):
+    # Generate solution point first
+    x = random.randint(-range_x, range_x)
+    y = random.randint(-range_y, range_y)
+    # Start from reduced echelon form (coeffs 1)
+    c1 = [1, 0, x]
+    c2 = [0, 1, y]
+
+    def randNonZero():
+        return random.choice(
+            [i for i in range(-coeff_mult_range, coeff_mult_range) if i != 0])
+
+    # Add random (non-zero) multiple of equations (rows) to each other
+    c1_mult = randNonZero()
+    c2_mult = randNonZero()
+    new_c1 = [c1[i] + c1_mult * c2[i] for i in range(len(c1))]
+    new_c2 = [c2[i] + c2_mult * c1[i] for i in range(len(c2))]
+    # For extra randomness, now add random (non-zero) multiples of original rows
+    # to themselves
+    c1_mult = randNonZero()
+    c2_mult = randNonZero()
+    new_c1 = [new_c1[i] + c1_mult * c1[i] for i in range(len(c1))]
+    new_c2 = [new_c2[i] + c2_mult * c2[i] for i in range(len(c2))]
+
+    def coeffToFuncString(coeffs):
+        # lots of edge cases for perfect formatting!
+        x_sign = '-' if coeffs[0] < 0 else ''
+        # No redundant 1s
+        x_coeff = str(abs(coeffs[0])) if abs(coeffs[0]) != 1 else ''
+        # If x coeff is 0, dont include x
+        x_str = f'{x_sign}{x_coeff}x' if coeffs[0] != 0 else ''
+        # if x isn't included and y is positive, dont include operator
+        op = ' - ' if coeffs[1] < 0 else (' + ' if x_str != '' else '')
+        # No redundant 1s
+        y_coeff = abs(coeffs[1]) if abs(coeffs[1]) != 1 else ''
+        # Don't include if 0, unless x is also 0 (probably never happens)
+        y_str = f'{y_coeff}y' if coeffs[1] != 0 else (
+            '' if x_str != '' else '0')
+        return f'{x_str}{op}{y_str} = {coeffs[2]}'
+
+    problem = f"{coeffToFuncString(new_c1)}, {coeffToFuncString(new_c2)}"
+    solution = f"x = {x}, y = {y}"
+    return problem, solution
+    # Add random (non-zero) multiple of equations to each other

mathgenerator/funcs/thirdAngleOfTriangleFunc.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+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

mathgenerator/funcs/vectorCrossFunc.py

@@ -0,0 +1,14 @@
+from .__init__ import *
+
+
+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]
+    ]
+
+    problem = str(a) + " X " + str(b) + " = "
+    solution = str(c)
+    return problem, solution

mathgenerator/funcs/vectorDotFunc.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+def vectorDotFunc(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[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+
+    problem = str(a) + " . " + str(b) + " = "
+    solution = str(c)
+    return problem, solution

mathgenerator/funcs/volumeCone.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+def volumeCone(maxRadius=20, maxHeight=50, unit='m'):
+    a = random.randint(1, maxHeight)
+    b = random.randint(1, maxRadius)
+
+    problem = f"Volume of cone with height = {a}{unit} and radius = {b}{unit} is"
+    ans = int(math.pi * b * b * a * (1 / 3))
+    solution = f"{ans} {unit}^3"
+    return problem, solution

mathgenerator/funcs/volumeCube.py

@@ -0,0 +1,10 @@
+from .__init__ import *
+
+
+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

mathgenerator/funcs/volumeCuboid.py

@@ -0,0 +1,12 @@
+from .__init__ import *
+
+
+def volumeCuboid(maxSide=20, unit='m'):
+    a = random.randint(1, maxSide)
+    b = random.randint(1, maxSide)
+    c = random.randint(1, maxSide)
+
+    problem = f"Volume of cuboid with sides = {a}{unit}, {b}{unit}, {c}{unit} is"
+    ans = a * b * c
+    solution = f"{ans} {unit}^3"
+    return problem, solution

mathgenerator/funcs/volumeCylinder.py

@@ -0,0 +1,11 @@
+from .__init__ import *
+
+
+def volumeCylinder(maxRadius=20, maxHeight=50, unit='m'):
+    a = random.randint(1, maxHeight)
+    b = random.randint(1, maxRadius)
+
+    problem = f"Volume of cylinder with height = {a}{unit} and radius = {b}{unit} is"
+    ans = int(math.pi * b * b * a)
+    solution = f"{ans} {unit}^3"
+    return problem, solution

mathgenerator/funcs/volumeSphereFunc.py

@@ -0,0 +1,10 @@
+from .__init__ import *
+
+
+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