Merge branch 'master' of https://github.com/Todarith/mathgenerator

 Conflicts:

	mathgenerator/mathgen.py

mathgenerator/__init__.py

@@ -1,3 +1,5 @@
+import sys
+import traceback
 genList = []
 
 
@@ -8,16 +10,22 @@ class Generator:
         self.generalProb = generalProb
         self.generalSol = generalSol
         self.func = func
-        genList.append([id, title, self])
+
+        (filename, line_number, function_name, text) = traceback.extract_stack()[-2]
+        funcname = filename[filename.rfind('/'):].strip()
+        funcname = funcname[1:-3]
+        # print(funcname)
+        genList.append([id, title, self, funcname])
 
     def __str__(self):
         return str(
             self.id
         ) + " " + self.title + " " + self.generalProb + " " + self.generalSol
 
-    def __call__(self, **kwargs):
-        return self.func(**kwargs)
+    def __call__(self, *args, **kwargs):
+        return self.func(*args, **kwargs)
 
 
 def getGenList():
-    return genList
+    correctedList = genList[-1:] + genList[:-1]
+    return correctedList

mathgenerator/funcs/__init__.py

@@ -2,85 +2,96 @@ import random
 import math
 import fractions
 
+from ..__init__ import *
+
 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 *
+from .subtraction import *
+from .multiplication import *
+from .division import *
+from .binary_complement_1s import *
+from .modulo_division import *
+from .square_root import *
+from .power_rule_differentiation import *
+from .square import *
+from .lcm import *
+from .gcd import *
+from .basic_algebra import *
+from .log import *
+from .int_division import *
+from .decimal_to_binary import *
+from .binary_to_decimal import *
+from .divide_fractions import *
+from .multiply_int_to_22_matrix import *
+from .area_of_triangle import *
+from .valid_triangle import *
+from .midpoint_of_two_points import *
+from .factoring import *
+from .third_angle_of_triangle import *
+from .system_of_equations import *
+from .distance_two_points import *
+from .pythagorean_theorem import *
+from .linear_equations import *
+from .prime_factors import *
+from .fraction_multiplication import *
+from .angle_regular_polygon import *
+from .combinations import *
+from .factorial import *
+from .surface_area_cube import *
+from .surface_area_cuboid import *
+from .surface_area_cylinder import *
+from .volume_cube import *
+from .volume_cuboid import *
+from .volume_cylinder import *
+from .surface_area_cone import *
+from .volume_cone import *
+from .common_factors import *
+from .intersection_of_two_lines import *
+from .permutation import *
+from .vector_cross import *
+from .compare_fractions import *
+from .simple_interest import *
+from .matrix_multiplication import *
+from .cube_root import *
+from .power_rule_integration import *
+from .fourth_angle_of_quadrilateral import *
+from .quadratic_equation import *
+from .hcf import *
+from .dice_sum_probability import *
+from .exponentiation import *
+from .confidence_interval import *
+from .surds_comparison import *
+from .fibonacci_series import *
+from .basic_trigonometry import *
+from .sum_of_polygon_angles import *
+from .data_summary import *
+from .surface_area_sphere import *
+from .volume_sphere import *
+from .nth_fibonacci_number import *
+from .profit_loss_percent import *
+from .binary_to_hex import *
+from .multiply_complex_numbers import *
+from .geometric_progression import *
+from .geometric_mean import *
+from .harmonic_mean import *
+from .euclidian_norm import *
+from .angle_btw_vectors import *
+from .absolute_difference import *
+from .vector_dot import *
+from .binary_2s_complement import *
+from .invert_matrix import *
+from .sector_area import *
+from .mean_median import *
+from .int_matrix_22_determinant import *
+from .compound_interest import *
+from .decimal_to_hexadeci import *
+from .percentage import *
+from .celsius_to_fahrenheit import *
+from .arithmetic_progression_term import *
+from .arithmetic_progression_sum import *
+from .decimal_to_octal import *
+from .decimal_to_roman_numerals import *
+from .degree_to_rad import *
+from .radian_to_deg import *
+from .differentiation import *
+from .definite_integral import *
+from .is_prime import *

mathgenerator/funcs/absolute_difference.py

@@ -10,3 +10,9 @@ def absoluteDifferenceFunc(maxA=100, maxB=100):
         str(a) + " and " + str(b) + " = "
     solution = absDiff
     return problem, solution
+
+
+absolute_difference = Generator(
+    "Absolute difference between two numbers", 71,
+    "Absolute difference betweeen two numbers a and b =", "|a-b|",
+    absoluteDifferenceFunc)

mathgenerator/funcs/addition.py

@@ -1,5 +1,4 @@
 from .__init__ import *
-from ..__init__ import Generator
 
 
 def additionFunc(maxSum=99, maxAddend=50):

mathgenerator/funcs/angleBtwVectorsFunc.py

@@ -1,16 +0,0 @@
-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/angle_btw_vectors.py

@@ -0,0 +1,28 @@
+from .__init__ import *
+import math
+
+
+def angleBtwVectorsFunc(maxEltAmt=20):
+    s = 0
+    v1 = [random.uniform(0, 1000) for i in range(random.randint(2, maxEltAmt))]
+    v2 = [random.uniform(0, 1000) for i in v1]
+    for i in v1:
+        for j in v2:
+            s += i * j
+
+    mags = math.sqrt(sum([i**2 for i in v1])) * math.sqrt(sum([i**2 for i in v2]))
+    problem = f"angle between the vectors {v1} and {v2} is:"
+    solution = ''
+    try:
+        solution = str(math.acos(s / mags))
+    except ValueError:
+        print('angleBtwVectorsFunc has some issues with math module, line 16')
+        solution = 'NaN'
+    # would return the answer in radians
+    return problem, solution
+
+
+angle_btw_vectors = Generator(
+    "Angle between 2 vectors", 70,
+    "Angle Between 2 vectors V1=[v11, v12, ..., v1n] and V2=[v21, v22, ....., v2n]",
+    "V1.V2 / (euclidNorm(V1)*euclidNorm(V2))", angleBtwVectorsFunc)

mathgenerator/funcs/angle_regular_polygon.py

@@ -8,3 +8,9 @@ def regularPolygonAngleFunc(minVal=3, maxVal=20):
     exteriorAngle = round((360 / sideNum), 2)
     solution = 180 - exteriorAngle
     return problem, solution
+
+
+angle_regular_polygon = Generator(
+    "Angle of a Regular Polygon", 29,
+    "Find the angle of a regular polygon with 6 sides", "120",
+    regularPolygonAngleFunc)

mathgenerator/funcs/area_of_triangle.py

@@ -13,3 +13,8 @@ def areaOfTriangleFunc(maxA=20, maxB=20, maxC=20):
         str(a) + " " + str(b) + " " + str(c) + " = "
     solution = area
     return problem, solution
+
+
+area_of_triangle = Generator("Area of Triangle", 18,
+                             "Area of Triangle with side lengths a, b, c = ",
+                             "area", areaOfTriangleFunc)

mathgenerator/funcs/arithmetic_progression_sum.py

@@ -0,0 +1,18 @@
+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
+
+
+arithmetic_progression_sum = Generator("AP Sum Calculation", 83,
+                                       "Find the sum of first n terms of the AP series: a1, a2, a3 ...",
+                                       "Sum", arithmeticProgressionSumFunc)

mathgenerator/funcs/arithmetic_progression_term.py

@@ -0,0 +1,18 @@
+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 problem, solution
+
+
+arithmetic_progression_term = Generator("AP Term Calculation", 82,
+                                        "Find the term number n of the AP series: a1, a2, a3 ...",
+                                        "a-n", arithmeticProgressionTermFunc)

mathgenerator/funcs/basic_algebra.py

@@ -23,3 +23,7 @@ def basicAlgebraFunc(maxVariable=10):
     problem = f"{a}x + {b} = {c}"
     solution = x
     return problem, solution
+
+
+basic_algebra = Generator("Basic Algebra", 11, "ax + b = c", "d",
+                          basicAlgebraFunc)

mathgenerator/funcs/basic_trigonometry.py

@@ -23,3 +23,7 @@ def basicTrigonometryFunc(angles=[0, 30, 45, 60, 90],
     solution = result_fraction_map[round(eval(expression), 2)] if round(
         eval(expression), 2) <= 99999 else "∞"  # for handling the ∞ condition
     return problem, solution
+
+
+basic_trigonometry = Generator("Trigonometric Values", 57, "What is sin(X)?",
+                               "ans", basicTrigonometryFunc)

mathgenerator/funcs/binary_2s_complement.py

@@ -26,3 +26,8 @@ def binary2sComplementFunc(maxDigits=10):
     problem = "2's complement of " + question + " ="
     solution = ''.join(answer).lstrip('0')
     return problem, solution
+
+
+binary_2s_complement = Generator("Binary 2's Complement", 73,
+                                 "2's complement of 11010110 =", "101010",
+                                 binary2sComplementFunc)

mathgenerator/funcs/binary_complement_1s.py

@@ -13,3 +13,7 @@ def binaryComplement1sFunc(maxDigits=10):
     problem = question + "="
     solution = answer
     return problem, solution
+
+
+binary_complement_1s = Generator("Binary Complement 1s", 4, "1010=", "0101",
+                                 binaryComplement1sFunc)

mathgenerator/funcs/binary_to_decimal.py

@@ -1,7 +1,7 @@
 from .__init__ import *
 
 
-def BinaryToDecimalFunc(max_dig=10):
+def binaryToDecimalFunc(max_dig=10):
     problem = ''
 
     for i in range(random.randint(1, max_dig)):
@@ -10,3 +10,7 @@ def BinaryToDecimalFunc(max_dig=10):
 
     solution = int(problem, 2)
     return problem, solution
+
+
+binary_to_decimal = Generator("Binary to Decimal", 15, "Decimal of a=", "b",
+                              binaryToDecimalFunc)

mathgenerator/funcs/binary_to_hex.py

@@ -9,3 +9,7 @@ def binaryToHexFunc(max_dig=10):
 
     solution = hex(int(problem, 2))
     return problem, solution
+
+
+binary_to_hex = Generator("Binary to Hexidecimal", 64, "Hexidecimal of a=", "b",
+                          binaryToHexFunc)

mathgenerator/funcs/celsius_to_fahrenheit.py

@@ -1,5 +1,4 @@
 from .__init__ import *
-from ..__init__ import Generator
 
 
 def celsiustofahrenheitFunc(maxTemp=100):
@@ -10,5 +9,5 @@ def celsiustofahrenheitFunc(maxTemp=100):
     return problem, solution
 
 
-celsiustofahrenheit = Generator("Celsius To Fahrenheit", 81,
-                                "(C +(9/5))+32=", "F", celsiustofahrenheitFunc)
+celsius_to_fahrenheit = Generator("Celsius To Fahrenheit", 81,
+                                  "(C +(9/5))+32=", "F", celsiustofahrenheitFunc)

mathgenerator/funcs/combinations.py

@@ -17,3 +17,9 @@ def combinationsFunc(maxlength=20):
         a, b)
 
     return problem, solution
+
+
+combinations = Generator(
+    "Combinations of Objects", 30,
+    "Combinations available for picking 4 objects at a time from 6 distinct objects =",
+    " 15", combinationsFunc)

mathgenerator/funcs/common_factors.py

@@ -22,3 +22,8 @@ def commonFactorsFunc(maxVal=100):
     problem = f"Common Factors of {a} and {b} = "
     solution = arr
     return problem, solution
+
+
+common_factors = Generator("Common Factors", 40,
+                           "Common Factors of {a} and {b} = ", "[c, d, ...]",
+                           commonFactorsFunc)

mathgenerator/funcs/compare_fractions.py

@@ -24,3 +24,9 @@ def compareFractionsFunc(maxVal=10):
 
     problem = f"Which symbol represents the comparison between {a}/{b} and {c}/{d}?"
     return problem, solution
+
+
+compare_fractions = Generator(
+    "Compare Fractions", 44,
+    "Which symbol represents the comparison between a/b and c/d?", ">/</=",
+    compareFractionsFunc)

mathgenerator/funcs/compound_interest.py

@@ -16,3 +16,9 @@ def compoundInterestFunc(maxPrinciple=10000,
                 t) + " compounded monthly is = "
     solution = round(A, 2)
     return problem, solution
+
+
+compound_interest = Generator(
+    "Compound Interest", 78,
+    "Compound interest for a principle amount of p dollars, r% rate of interest and for a time period of t years with n times compounded annually is = ",
+    "A dollars", compoundInterestFunc)

mathgenerator/funcs/confidence_interval.py

@@ -29,3 +29,8 @@ def confidenceIntervalFunc():
         [x for x in lst], lst_per[j])
     solution = '({}, {})'.format(mean + standard_error, mean - standard_error)
     return problem, solution
+
+
+confidence_interval = Generator("Confidence interval For sample S", 54,
+                                "With X% confidence", "is (A,B)",
+                                confidenceIntervalFunc)

mathgenerator/funcs/cube_root.py

@@ -8,3 +8,7 @@ def cubeRootFunc(minNo=1, maxNo=1000):
     problem = "cuberoot of " + str(b) + " upto 2 decimal places is:"
     solution = str(round(a, 2))
     return problem, solution
+
+
+cube_root = Generator("Cube Root", 47, "Cuberoot of a upto 2 decimal places is",
+                      "b", cubeRootFunc)

mathgenerator/funcs/data_summary.py

@@ -15,14 +15,15 @@ def dataSummaryFunc(number_values=15, minval=5, maxval=50):
     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)
+    standardDeviation = var / number_values
+    variance = (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)
+        mean, standardDeviation, variance)
     return problem, solution
+
+
+data_summary = Generator("Mean,Standard Deviation,Variance", 59, "a,b,c",
+                         "Mean:a+b+c/3,Std,Var", dataSummaryFunc)

mathgenerator/funcs/decimal_to_binary.py

@@ -9,3 +9,7 @@ def DecimalToBinaryFunc(max_dec=99):
     solution = str(b)
 
     return problem, solution
+
+
+decimal_to_binary = Generator("Decimal to Binary", 14, "Binary of a=", "b",
+                              DecimalToBinaryFunc)

mathgenerator/funcs/decimal_to_hexadeci.py

@@ -8,3 +8,7 @@ def deciToHexaFunc(max_dec=1000):
     solution = str(b)
 
     return problem, solution
+
+
+decimal_to_hexadeci = Generator("Decimal to Hexadecimal", 79, "Binary of a=",
+                                "b", deciToHexaFunc)

mathgenerator/funcs/decimal_to_octal.py

@@ -0,0 +1,12 @@
+from .__init__ import *
+
+
+def decimalToOctalFunc(maxDecimal=4096):
+    x = random.randint(0, maxDecimal)
+    problem = "The decimal number " + str(x) + " in Octal is: "
+    solution = oct(x)
+    return problem, solution
+
+
+decimal_to_octal = Generator("Converts decimal to octal", 84,
+                             "What's the octal representation of 98?", "0o142", decimalToOctalFunc)

mathgenerator/funcs/decimal_to_roman_numerals.py

@@ -0,0 +1,29 @@
+from .__init__ import *
+
+
+def decimalToRomanNumeralsFunc(maxDecimal=4000):
+    x = random.randint(0, maxDecimal)
+    problem = "The number " + str(x) + " in Roman Numerals is: "
+    roman_dict = {1: "I", 5: "V", 10: "X", 50: "L", 100: "C", 500: "D", 1000: "M"}
+    divisor = 1
+    while x >= divisor:
+        divisor *= 10
+    divisor /= 10
+    solution = ""
+    while x:
+        last_value = int(x / divisor)
+        if last_value <= 3:
+            solution += (roman_dict[divisor] * last_value)
+        elif last_value == 4:
+            solution += (roman_dict[divisor] + roman_dict[divisor * 5])
+        elif 5 <= last_value <= 8:
+            solution += (roman_dict[divisor * 5] + (roman_dict[divisor] * (last_value - 5)))
+        elif last_value == 9:
+            solution += (roman_dict[divisor] + roman_dict[divisor * 10])
+        x = math.floor(x % divisor)
+        divisor /= 10
+    return problem, solution
+
+
+decimal_to_roman_numerals = Generator("Converts decimal to Roman Numerals",
+                                      85, "Convert 20 into Roman Numerals", "XX", decimalToRomanNumeralsFunc)

mathgenerator/funcs/definite_integral.py

@@ -0,0 +1,27 @@
+from .__init__ import *
+import scipy
+from scipy.integrate import quad
+
+
+def definiteIntegralFunc(max_coeff=100):
+
+    def integrand(x, a, b, c):
+        return a * x ** 2 + b * x + c
+
+    a = random.randint(0, max_coeff)
+    b = random.randint(0, max_coeff)
+    c = random.randint(0, max_coeff)
+
+    result = quad(integrand, 0, 1, args=(a, b, c))[0]
+    S = round(result, 4)
+
+    problem = "The definite integral within limits 0 to 1 of the equation " + \
+        str(a) + "x^2 + " + str(b) + "x + " + str(c) + " is = "
+
+    solution = str(S)
+
+    return problem, solution
+
+
+definite_integral = Generator("Definite Integral of Quadratic Equation", 89,
+                              "The definite integral within limits 0 to 1 of quadratic equation ax^2+bx+c is = ", "S", definiteIntegralFunc)

mathgenerator/funcs/degree_to_rad.py

@@ -0,0 +1,17 @@
+from .__init__ import *
+from numpy import pi
+
+
+def degreeToRadFunc(max_deg=360):
+    a = random.randint(0, max_deg)
+    b = (pi * a) / 180
+    b = round(b, 2)
+
+    problem = "Angle " + str(a) + " in radians is = "
+    solution = str(b)
+
+    return problem, solution
+
+
+degree_to_rad = Generator("Degrees to Radians", 86,
+                          "Angle a in radians is = ", "b", degreeToRadFunc)

mathgenerator/funcs/dice_sum_probability.py

@@ -24,3 +24,9 @@ def DiceSumProbFunc(maxDice=3):
         a, b)
     solution = "{}/{}".format(count, 6**a)
     return problem, solution
+
+
+dice_sum_probability = Generator(
+    "Probability of a certain sum appearing on faces of dice", 52,
+    "If n dices are rolled then probabilty of getting sum of x is =", "z",
+    DiceSumProbFunc)

mathgenerator/funcs/differentiation.py

@@ -0,0 +1,53 @@
+from .__init__ import *
+
+
+def genDifferentiationProblem(diff_lvl):
+    problem = ''
+
+    types = {
+        'Logrithmic': ['ln'],
+        'Trigonometric': ['sin', 'cos', 'tan', 'cot', 'sec'],
+        'Exponentional': ['exp']
+    }
+
+    if diff_lvl == 1:
+        coeff = random.randrange(2, 10)
+        power = random.randint(2, 4)
+        flag = random.random()
+        if flag > 0.5:
+            power *= -1
+            problem += str(coeff) + '*x^' + '(' + str(power) + ')'
+        else:
+            problem += str(coeff) + '*x^' + str(power)
+    if diff_lvl == 2:
+        func_type = random.choices(list(types.keys()), weights=(1, 4, 1))[0]
+        func = random.choice(types[func_type])
+        problem += func + '(x)' + '+' + genDifferentiationProblem(1)
+    if diff_lvl == 3:
+        func_type = random.choices(list(types.keys()), weights=(1, 4, 1))[0]
+        func = random.choice(types[func_type])
+        problem += func + '(' + genDifferentiationProblem(1) + ')'
+    if diff_lvl == 4:
+        operator = random.choice(('/', '*'))
+        problem = '(' + genDifferentiationProblem(2) + ')' + \
+            operator + '(' + genDifferentiationProblem(3) + ')'
+
+    return problem
+
+
+def differentiationFunc(diff_lvl=2):
+    if diff_lvl < 1 or diff_lvl > 4:
+        print("diff_lvl not supported")
+        return None
+    problem = genDifferentiationProblem(diff_lvl)
+
+    x = sympy.symbols('x')
+    solution = str(sympy.diff(problem.replace('^', '**'), x))
+    solution = solution.replace('**', '^')
+    problem = f"differentiate w.r.t x : d({problem})/dx"
+
+    return problem, solution
+
+
+differentiation = Generator(
+    "Differentiation", 88, "differentiate w.r.t x : d(f(x))/dx", "g(x)", differentiationFunc)

mathgenerator/funcs/distance_two_points.py

@@ -12,3 +12,8 @@ def distanceTwoPointsFunc(maxValXY=20, minValXY=-20):
     solution = f"sqrt({distanceSq})"
     problem = f"Find the distance between ({point1X}, {point1Y}) and ({point2X}, {point2Y})"
     return problem, solution
+
+
+distance_two_points = Generator("Distance between 2 points", 24,
+                                "Find the distance between (x1,y1) and (x2,y2)",
+                                "sqrt(distanceSquared)", distanceTwoPointsFunc)

mathgenerator/funcs/divide_fractions.py

@@ -30,3 +30,7 @@ def divideFractionsFunc(maxVal=10):
     problem = f"({a}/{b})/({c}/{d})"
     solution = x
     return problem, solution
+
+
+divide_fractions = Generator("Fraction Division", 16, "(a/b)/(c/d)=", "x/y",
+                             divideFractionsFunc)

mathgenerator/funcs/division.py

@@ -9,3 +9,6 @@ def divisionFunc(maxRes=99, maxDivid=99):
     problem = str(a) + "/" + str(b) + "="
     solution = str(c)
     return problem, solution
+
+
+division = Generator("Division", 3, "a/b=", "c", divisionFunc)

mathgenerator/funcs/euclidianNormFunc.py

@@ -1,7 +0,0 @@
-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/euclidian_norm.py

@@ -0,0 +1,13 @@
+from .__init__ import *
+
+
+def euclidianNormFunc(maxEltAmt=20):
+    vec = [random.uniform(0, 1000) for i in range(random.randint(2, maxEltAmt))]
+    problem = f"Euclidian norm or L2 norm of the vector{vec} is:"
+    solution = math.sqrt(sum([i**2 for i in vec]))
+    return problem, solution
+
+
+eucldian_norm = Generator("Euclidian norm or L2 norm of a vector", 69,
+                          "Euclidian Norm of a vector V:[v1, v2, ......., vn]",
+                          "sqrt(v1^2 + v2^2 ........ +vn^2)", euclidianNormFunc)

mathgenerator/funcs/exponentiation.py

@@ -8,3 +8,7 @@ def exponentiationFunc(maxBase=20, maxExpo=10):
     problem = f"{base}^{expo} ="
     solution = str(base**expo)
     return problem, solution
+
+
+exponentiation = Generator("Exponentiation", 53, "a^b = ", "c",
+                           exponentiationFunc)

mathgenerator/funcs/factorial.py

@@ -13,3 +13,6 @@ def factorialFunc(maxInput=6):
         n -= 1
     solution = str(b)
     return problem, solution
+
+
+factorial = Generator("Factorial", 31, "a! = ", "b", factorialFunc)

mathgenerator/funcs/factoring.py

@@ -27,3 +27,7 @@ def factoringFunc(range_x1=10, range_x2=10):
     x2 = intParser(x2)
     solution = f"(x{x1})(x{x2})"
     return problem, solution
+
+
+factoring = Generator("Factoring Quadratic", 21, "x^2+(x1+x2)+x1*x2",
+                      "(x-x1)(x-x2)", factoringFunc)

mathgenerator/funcs/fibonacci_series.py

@@ -19,3 +19,8 @@ def fibonacciSeriesFunc(minNo=1):
     problem = "The Fibonacci Series of the first " + str(n) + " numbers is ?"
     solution = fibList
     return problem, solution
+
+
+fibonacci_series = Generator(
+    "Fibonacci Series", 56, "fibonacci series of first a numbers",
+    "prints the fibonacci series starting from 0 to a", fibonacciSeriesFunc)

mathgenerator/funcs/fourth_angle_of_quadrilateral.py

@@ -12,3 +12,9 @@ def fourthAngleOfQuadriFunc(maxAngle=180):
     problem = f"Fourth angle of quadrilateral with angles {angle1} , {angle2}, {angle3} ="
     solution = angle4
     return problem, solution
+
+
+fourth_angle_of_quadrilateral = Generator(
+    "Fourth Angle of Quadrilateral", 49,
+    "Fourth angle of Quadrilateral with angles a,b,c =", "angle4",
+    fourthAngleOfQuadriFunc)

mathgenerator/funcs/fraction_multiplication.py

@@ -30,3 +30,8 @@ def multiplyFractionsFunc(maxVal=10):
     problem = f"({a}/{b})*({c}/{d})"
     solution = x
     return problem, solution
+
+
+fraction_multiplication = Generator("Fraction Multiplication", 28,
+                                    "(a/b)*(c/d)=", "x/y",
+                                    multiplyFractionsFunc)

mathgenerator/funcs/gcd.py

@@ -10,3 +10,7 @@ def gcdFunc(maxVal=20):
     problem = f"GCD of {a} and {b} = "
     solution = str(x)
     return problem, solution
+
+
+gcd = Generator("GCD (Greatest Common Denominator)", 10, "GCD of a and b = ",
+                "c", gcdFunc)

mathgenerator/funcs/geometric_mean.py

@@ -25,3 +25,8 @@ def geometricMeanFunc(maxValue=100, maxNum=4):
         problem = f"Geometric mean of {num} numbers {a} , {b} , {c} , {d} = "
         solution = f"({a}*{b}*{c}*{d})^(1/{num}) = {ans}"
     return problem, solution
+
+
+geometric_mean = Generator("Geometric Mean of N Numbers", 67,
+                           "Geometric mean of n numbers A1 , A2 , ... , An = ",
+                           "(A1*A2*...An)^(1/n) = ans", geometricMeanFunc)

mathgenerator/funcs/geometric_progression.py

@@ -21,3 +21,9 @@ def geomProgrFunc(number_values=6,
     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
+
+
+geometric_progression = Generator(
+    "Geometric Progression", 66,
+    "Initial value,Common Ratio,nth Term,Sum till nth term =",
+    "a,r,ar^n-1,sum(ar^n-1", geomProgrFunc)

mathgenerator/funcs/harmonic_mean.py

@@ -26,3 +26,9 @@ def harmonicMeanFunc(maxValue=100, maxNum=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
+
+
+harmonic_mean = Generator("Harmonic Mean of N Numbers", 68,
+                          "Harmonic mean of n numbers A1 , A2 , ... , An = ",
+                          " n/((1/A1) + (1/A2) + ... + (1/An)) = ans",
+                          harmonicMeanFunc)

mathgenerator/funcs/hcf.py

@@ -10,3 +10,7 @@ def hcfFunc(maxVal=20):
     problem = f"HCF of {a} and {b} = "
     solution = str(x)
     return problem, solution
+
+
+hcf = Generator("HCF (Highest Common Factor)", 51, "HCF of a and b = ", "c",
+                hcfFunc)

mathgenerator/funcs/int_division.py

@@ -11,3 +11,6 @@ def divisionToIntFunc(maxA=25, maxB=25):
     problem = f"{divisor}/{dividend} = "
     solution = int(divisor / dividend)
     return problem, solution
+
+
+int_division = Generator("Easy Division", 13, "a/b=", "c", divisionToIntFunc)

mathgenerator/funcs/int_matrix_22_determinant.py

@@ -11,3 +11,8 @@ def determinantToMatrix22(maxMatrixVal=100):
     problem = f"Det([[{a}, {b}], [{c}, {d}]]) = "
     solution = f" {determinant}"
     return problem, solution
+
+
+int_matrix_22_determinant = Generator("Determinant to 2x2 Matrix", 77,
+                                      "Det([[a,b],[c,d]]) =", " a * d - b * c",
+                                      determinantToMatrix22)

mathgenerator/funcs/intersection_of_two_lines.py

@@ -64,3 +64,9 @@ def intersectionOfTwoLinesFunc(minM=-10,
         solution = f"({fractionToString(intersection_x)}, {fractionToString(intersection_y)})"
 
     return problem, solution
+
+
+intersection_of_two_lines = 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)

mathgenerator/funcs/invert_matrix.py

@@ -76,3 +76,7 @@ def matrixInversion(SquareMatrixDimension=3,
     problem = 'Inverse of Matrix ' + str(Mat) + ' is:'
     solution = str(sympy.Matrix.inv(Mat))
     return problem, solution
+
+
+invert_matrix = Generator("Inverse of a Matrix", 74, "Inverse of a matrix A is",
+                          "A^(-1)", matrixInversion)

mathgenerator/funcs/is_prime.py

@@ -0,0 +1,22 @@
+from .__init__ import *
+
+
+def isprime(max_a=100):
+    a = random.randint(2, max_a)
+    problem = a
+    if a == 2:
+        solution = True
+        return (problem, solution)
+    if a % 2 == 0:
+        solution = False
+        return (problem, solution)
+    for i in range(3, a // 2 + 1, 2):
+        if a % i == 0:
+            solution = False
+            return (problem, solution)
+    solution = True
+    return (problem, solution)
+
+
+is_prime = Generator('isprime', 90, 'a any positive integer',
+                     'True/False', isprime)

mathgenerator/funcs/lcm.py

@@ -15,3 +15,7 @@ def lcmFunc(maxVal=20):
     solution = str(d)
 
     return problem, solution
+
+
+lcm = Generator("LCM (Least Common Multiple)", 9, "LCM of a and b = ", "c",
+                lcmFunc)

mathgenerator/funcs/linear_equations.py

@@ -25,5 +25,10 @@ def linearEquationsFunc(n=2, varRange=20, coeffRange=20):
         prob = " + ".join(prob) + " = " + str(res)
         problem.append(prob)
 
-    problem = "\n".join(problem)
+    # problem = "\n".join(problem)
+    problem = ", ".join(problem)
     return problem, solution
+
+
+linear_equations = Generator("Linear Equations", 26, "2x+5y=20 & 3x+6y=12",
+                             "x=-20 & y=12", linearEquationsFunc)

mathgenerator/funcs/log.py

@@ -10,3 +10,6 @@ def logFunc(maxBase=3, maxVal=8):
     solution = str(a)
 
     return problem, solution
+
+
+log = Generator("Logarithm", 12, "log2(8)", "3", logFunc)

mathgenerator/funcs/matrix_multiplication.py

@@ -1,10 +1,10 @@
 from .__init__ import *
 
 
-def matrixMultiplicationFunc(maxVal=100):
-    m = random.randint(2, 10)
-    n = random.randint(2, 10)
-    k = random.randint(2, 10)
+def matrixMultiplicationFunc(maxVal=100, max_dim=10):
+    m = random.randint(2, max_dim)
+    n = random.randint(2, max_dim)
+    k = random.randint(2, max_dim)
 
     # generate matrices a and b
     a = []
@@ -51,3 +51,8 @@ def matrixMultiplicationFuncHelper(inp):
     string += "]]"
 
     return string
+
+
+matrix_multiplication = Generator("Multiplication of two matrices", 46,
+                                  "Multiply two matrices A and B", "C",
+                                  matrixMultiplicationFunc)

mathgenerator/funcs/mean_median.py

@@ -12,3 +12,8 @@ def meanMedianFunc(maxlen=10):
     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
+
+
+mean_median = Generator("Mean and Median", 76,
+                        "Mean and median of given set of numbers",
+                        "Mean, Median", meanMedianFunc)

mathgenerator/funcs/midpoint_of_two_points.py

@@ -10,3 +10,8 @@ def MidPointOfTwoPointFunc(maxValue=20):
     problem = f"({x1},{y1}),({x2},{y2})="
     solution = f"({(x1+x2)/2},{(y1+y2)/2})"
     return problem, solution
+
+
+midPoint_of_two_points = Generator("Midpoint of the two point", 20,
+                                   "((X1,Y1),(X2,Y2))=", "((X1+X2)/2,(Y1+Y2)/2)",
+                                   MidPointOfTwoPointFunc)

mathgenerator/funcs/modulo_division.py

@@ -9,3 +9,6 @@ def moduloFunc(maxRes=99, maxModulo=99):
     problem = str(a) + "%" + str(b) + "="
     solution = str(c)
     return problem, solution
+
+
+modulo_division = Generator("Modulo Division", 5, "a%b=", "c", moduloFunc)

mathgenerator/funcs/multiplication.py

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

mathgenerator/funcs/multiplicationFunc.py

@@ -1,11 +0,0 @@
-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/multiply_complex_numbers.py

@@ -10,3 +10,8 @@ def multiplyComplexNumbersFunc(minRealImaginaryNum=-20,
     problem = f"{num1} * {num2} = "
     solution = num1 * num2
     return problem, solution
+
+
+multiply_complex_numbers = Generator("Multiplication of 2 complex numbers", 65,
+                                     "(x + j) (y + j) = ", "xy + xj + yj -1",
+                                     multiplyComplexNumbersFunc)

mathgenerator/funcs/multiply_int_to_22_matrix.py

@@ -11,3 +11,9 @@ def multiplyIntToMatrix22(maxMatrixVal=10, maxRes=100):
     problem = f"{constant} * [[{a}, {b}], [{c}, {d}]] = "
     solution = f"[[{a*constant},{b*constant}],[{c*constant},{d*constant}]]"
     return problem, solution
+
+
+multiply_int_to_22_matrix = Generator("Integer Multiplication with 2x2 Matrix",
+                                      17, "k * [[a,b],[c,d]]=",
+                                      "[[k*a,k*b],[k*c,k*d]]",
+                                      multiplyIntToMatrix22)

mathgenerator/funcs/nth_fibonacci_number.py

@@ -8,3 +8,8 @@ def nthFibonacciNumberFunc(maxN=100):
     ans = round((math.pow(golden_ratio, n) - math.pow(-golden_ratio, -n)) / (math.sqrt(5)))
     solution = f"{ans}"
     return problem, solution
+
+
+nth_fibonacci_number = Generator("nth Fibonacci number", 62,
+                                 "What is the nth Fibonacci number", "Fn",
+                                 nthFibonacciNumberFunc)

mathgenerator/funcs/percentage.py

@@ -9,3 +9,7 @@ def percentageFunc(maxValue=99, maxpercentage=99):
     formatted_float = "{:.2f}".format(percentage)
     solution = f"Required percentage = {formatted_float}%"
     return problem, solution
+
+
+percentage = Generator("Percentage of a number", 80, "What is a% of b?",
+                       "percentage", percentageFunc)

mathgenerator/funcs/permutation.py

@@ -9,3 +9,9 @@ def permutationFunc(maxlength=20):
     problem = "Number of Permutations from {} objects picked {} at a time =  ".format(
         a, b)
     return problem, solution
+
+
+permutation = Generator(
+    "Permutations", 42,
+    "Total permutations of 4 objects at a time from 10 objects is", "5040",
+    permutationFunc)

mathgenerator/funcs/power_rule_differentiation.py

@@ -16,3 +16,8 @@ def powerRuleDifferentiationFunc(maxCoef=10, maxExp=10, maxTerms=5):
         problem += str(coefficient) + "x^" + str(exponent)
         solution += str(coefficient * exponent) + "x^" + str(exponent - 1)
     return problem, solution
+
+
+power_rule_differentiation = Generator("Power Rule Differentiation", 7, "nx^m=",
+                                       "(n*m)x^(m-1)",
+                                       powerRuleDifferentiationFunc)

mathgenerator/funcs/power_rule_integration.py

@@ -19,3 +19,7 @@ def powerRuleIntegrationFunc(maxCoef=10, maxExp=10, maxTerms=5):
 
     solution += " + c"
     return problem, solution
+
+
+power_rule_integration = Generator("Power Rule Integration", 48, "nx^m=",
+                                   "(n/m)x^(m+1)", powerRuleIntegrationFunc)

mathgenerator/funcs/prime_factors.py

@@ -20,3 +20,7 @@ def primeFactorsFunc(minVal=1, maxVal=200):
     problem = f"Find prime factors of {a}"
     solution = f"{factors}"
     return problem, solution
+
+
+prime_factors = Generator("Prime Factorisation", 27, "Prime Factors of a =",
+                          "[b, c, d, ...]", primeFactorsFunc)

mathgenerator/funcs/profit_loss_percent.py

@@ -14,3 +14,9 @@ def profitLossPercentFunc(maxCP=1000, maxSP=1000):
     solution = percent
 
     return problem, solution
+
+
+profit_loss_percent = Generator(
+    "Profit or Loss Percent", 63,
+    "Profit/ Loss percent when CP = cp and SP = sp is: ", "percent",
+    profitLossPercentFunc)

mathgenerator/funcs/pythagorean_theorem.py

@@ -9,3 +9,9 @@ def pythagoreanTheoremFunc(maxLength=20):
     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
+
+
+pythagorean_theorem = Generator(
+    "Pythagorean Theorem", 25,
+    "The hypotenuse of a right triangle given the other two lengths a and b = ",
+    "hypotenuse", pythagoreanTheoremFunc)

mathgenerator/funcs/quadratic_equation.py

@@ -13,3 +13,9 @@ def quadraticEquation(maxVal=100):
         [round((-b + D) / (2 * a), 2),
          round((-b - D) / (2 * a), 2)])
     return problem, solution
+
+
+quadratic_equation = Generator(
+    "Quadratic Equation", 50,
+    "Find the zeros {x1,x2} of the quadratic equation ax^2+bx+c=0", "x1,x2",
+    quadraticEquation)

mathgenerator/funcs/radian_to_deg.py

@@ -0,0 +1,18 @@
+from .__init__ import *
+from numpy import pi
+
+
+def radianToDegFunc(max_rad=3):
+    # max_rad is supposed to be pi but random can't handle non-integer
+    a = random.randint(0, max_rad)
+    b = (180 * a) / pi
+    b = round(b, 2)
+
+    problem = "Angle " + str(a) + " in degrees is = "
+    solution = str(b)
+
+    return problem, solution
+
+
+radian_to_deg = Generator("Radians to Degrees", 87,
+                          "Angle a in degrees is = ", "b", radianToDegFunc)

mathgenerator/funcs/sector_area.py

@@ -9,3 +9,8 @@ def sectorAreaFunc(maxRadius=49, maxAngle=359):
     formatted_float = "{:.5f}".format(secArea)
     solution = f"Area of sector = {formatted_float}"
     return problem, solution
+
+
+sector_area = Generator("Area of a Sector", 75,
+                        "Area of a sector with radius, r and angle, a ", "Area",
+                        sectorAreaFunc)

mathgenerator/funcs/simple_interest.py

@@ -13,3 +13,9 @@ def simpleInterestFunc(maxPrinciple=10000, maxRate=10, maxTime=10):
                 c) + " years is = "
     solution = round(d, 2)
     return problem, solution
+
+
+simple_interest = 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)

mathgenerator/funcs/square.py

@@ -8,3 +8,6 @@ def squareFunc(maxSquareNum=20):
     problem = str(a) + "^2" + "="
     solution = str(b)
     return problem, solution
+
+
+square = Generator("Square", 8, "a^2", "b", squareFunc)

mathgenerator/funcs/square_root.py

@@ -8,3 +8,6 @@ def squareRootFunc(minNo=1, maxNo=12):
     problem = "sqrt(" + str(a) + ")="
     solution = str(b)
     return problem, solution
+
+
+square_root = Generator("Square Root", 6, "sqrt(a)=", "b", squareRootFunc)

mathgenerator/funcs/subtraction.py

@@ -9,3 +9,6 @@ def subtractionFunc(maxMinuend=99, maxDiff=99):
     problem = str(a) + "-" + str(b) + "="
     solution = str(c)
     return problem, solution
+
+
+subtraction = Generator("Subtraction", 1, "a-b=", "c", subtractionFunc)

mathgenerator/funcs/sum_of_polygon_angles.py

@@ -8,3 +8,8 @@ def sumOfAnglesOfPolygonFunc(maxSides=12):
     problem = f"Sum of angles of polygon with {side} sides = "
     solution = sum
     return problem, solution
+
+
+sum_of_polygon_angles = Generator("Sum of Angles of Polygon", 58,
+                                  "Sum of angles of polygon with n sides = ",
+                                  "sum", sumOfAnglesOfPolygonFunc)

mathgenerator/funcs/surds_comparison.py

@@ -15,3 +15,8 @@ def surdsComparisonFunc(maxValue=100, maxRoot=10):
     elif first < second:
         solution = "<"
     return problem, solution
+
+
+surds_comparison = Generator("Comparing surds", 55,
+                             "Fill in the blanks a^(1/b) _ c^(1/d)", "</>/=",
+                             surdsComparisonFunc)

mathgenerator/funcs/surface_area_cone.py

@@ -11,3 +11,9 @@ def surfaceAreaCone(maxRadius=20, maxHeight=50, unit='m'):
 
     solution = f"{ans} {unit}^2"
     return problem, solution
+
+
+surface_area_cone = Generator(
+    "Surface Area of cone", 38,
+    "Surface area of cone with height = a units and radius = b units is",
+    "c units^2", surfaceAreaCone)

mathgenerator/funcs/surface_area_cube.py

@@ -7,3 +7,8 @@ def surfaceAreaCube(maxSide=20, unit='m'):
     ans = 6 * a * a
     solution = f"{ans} {unit}^2"
     return problem, solution
+
+
+surface_area_cube = Generator("Surface Area of Cube", 32,
+                              "Surface area of cube with side a units is",
+                              "b units^2", surfaceAreaCube)

mathgenerator/funcs/surface_area_cuboid.py

@@ -10,3 +10,9 @@ def surfaceAreaCuboid(maxSide=20, unit='m'):
     ans = 2 * (a * b + b * c + c * a)
     solution = f"{ans} {unit}^2"
     return problem, solution
+
+
+surface_area_cuboid = Generator(
+    "Surface Area of Cuboid", 33,
+    "Surface area of cuboid with sides = a units, b units, c units is",
+    "d units^2", surfaceAreaCuboid)

mathgenerator/funcs/surface_area_cylinder.py

@@ -9,3 +9,9 @@ def surfaceAreaCylinder(maxRadius=20, maxHeight=50, unit='m'):
     ans = int(2 * math.pi * a * b + 2 * math.pi * b * b)
     solution = f"{ans} {unit}^2"
     return problem, solution
+
+
+surface_area_cylinder = Generator(
+    "Surface Area of Cylinder", 34,
+    "Surface area of cylinder with height = a units and radius = b units is",
+    "c units^2", surfaceAreaCylinder)

mathgenerator/funcs/surface_area_sphere.py

@@ -8,3 +8,9 @@ def surfaceAreaSphere(maxSide=20, unit='m'):
     ans = 4 * math.pi * r * r
     solution = f"{ans} {unit}^2"
     return problem, solution
+
+
+surface_area_sphere = Generator(
+    "Surface Area of Sphere", 60,
+    "Surface area of sphere with radius = a units is", "d units^2",
+    surfaceAreaSphere)

mathgenerator/funcs/system_of_equations.py

@@ -45,3 +45,8 @@ def systemOfEquationsFunc(range_x=10, range_y=10, coeff_mult_range=10):
     solution = f"x = {x}, y = {y}"
     return problem, solution
     # Add random (non-zero) multiple of equations to each other
+
+
+system_of_equations = Generator("Solve a System of Equations in R^2", 23,
+                                "2x + 5y = 13, -3x - 3y = -6", "x = -1, y = 3",
+                                systemOfEquationsFunc)

mathgenerator/funcs/third_angle_of_triangle.py

@@ -9,3 +9,8 @@ def thirdAngleOfTriangleFunc(maxAngle=89):
     problem = f"Third angle of triangle with angles {angle1} and {angle2} = "
     solution = angle3
     return problem, solution
+
+
+third_angle_of_triangle = Generator("Third Angle of Triangle", 22,
+                                    "Third Angle of the triangle = ", "angle3",
+                                    thirdAngleOfTriangleFunc)

mathgenerator/funcs/valid_triangle.py

@@ -18,3 +18,8 @@ def isTriangleValidFunc(maxSideLength=50):
         return problem, solution
     solution = "No"
     return problem, solution
+
+
+valid_triangle = Generator("Triangle exists check", 19,
+                           "Does triangle with sides a, b and c exist?",
+                           "Yes/No", isTriangleValidFunc)

mathgenerator/funcs/vector_cross.py

@@ -12,3 +12,7 @@ def vectorCrossFunc(minVal=-20, maxVal=20):
     problem = str(a) + " X " + str(b) + " = "
     solution = str(c)
     return problem, solution
+
+
+vector_cross = Generator("Cross Product of 2 Vectors", 43, "a X b = ", "c",
+                         vectorCrossFunc)

mathgenerator/funcs/vector_dot.py

@@ -9,3 +9,7 @@ def vectorDotFunc(minVal=-20, maxVal=20):
     problem = str(a) + " . " + str(b) + " = "
     solution = str(c)
     return problem, solution
+
+
+vector_dot = Generator("Dot Product of 2 Vectors", 72, "a . b = ", "c",
+                       vectorDotFunc)

mathgenerator/funcs/volume_cone.py

@@ -9,3 +9,9 @@ def volumeCone(maxRadius=20, maxHeight=50, unit='m'):
     ans = int(math.pi * b * b * a * (1 / 3))
     solution = f"{ans} {unit}^3"
     return problem, solution
+
+
+volume_cone = Generator(
+    "Volume of cone", 39,
+    "Volume of cone with height = a units and radius = b units is",
+    "c units^3", volumeCone)

mathgenerator/funcs/volume_cube.py

@@ -8,3 +8,8 @@ def volumeCube(maxSide=20, unit='m'):
     ans = a * a * a
     solution = f"{ans} {unit}^3"
     return problem, solution
+
+
+volume_cube = Generator("Volum of Cube", 35,
+                        "Volume of cube with side a units is", "b units^3",
+                        volumeCube)

mathgenerator/funcs/volume_cuboid.py

@@ -10,3 +10,9 @@ def volumeCuboid(maxSide=20, unit='m'):
     ans = a * b * c
     solution = f"{ans} {unit}^3"
     return problem, solution
+
+
+volume_cuboid = Generator(
+    "Volume of Cuboid", 36,
+    "Volume of cuboid with sides = a units, b units, c units is", "d units^3",
+    volumeCuboid)

mathgenerator/funcs/volume_cylinder.py

@@ -9,3 +9,9 @@ def volumeCylinder(maxRadius=20, maxHeight=50, unit='m'):
     ans = int(math.pi * b * b * a)
     solution = f"{ans} {unit}^3"
     return problem, solution
+
+
+volume_cylinder = Generator(
+    "Volume of cylinder", 37,
+    "Volume of cylinder with height = a units and radius = b units is",
+    "c units^3", volumeCylinder)

mathgenerator/funcs/volume_sphere.py

@@ -8,3 +8,8 @@ def volumeSphereFunc(maxRadius=100):
     ans = (4 * math.pi / 3) * r * r * r
     solution = f"{ans} m^3"
     return problem, solution
+
+
+volume_sphere = Generator("Volume of Sphere", 61,
+                          "Volume of sphere with radius r m = ",
+                          "(4*pi/3)*r*r*r", volumeSphereFunc)

mathgenerator/mathgen.py

@@ -1,274 +1,11 @@
-import random
-import math
-import fractions
 from .funcs import *
 from .__init__ import getGenList
 
+
 genList = getGenList()
 
-# || Generator class
-
-
-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)
-
 
 # || Non-generator Functions
 def genById(id):
     generator = genList[id][2]
     return (generator())
-
-
-#
-# def getGenList():
-#    return(genList)
-
-# Format is:
-# <title> = Generator("<Title>", <id>, <generalized problem>, <generalized solution>, <function name>)
-# Funcs_start - DO NOT REMOVE!
-# addition = Generator("Addition", 0, "a+b=", "c", additionFunc)
-subtraction = Generator("Subtraction", 1, "a-b=", "c", subtractionFunc)
-multiplication = Generator("Multiplication", 2, "a*b=", "c",
-                           multiplicationFunc)
-division = Generator("Division", 3, "a/b=", "c", divisionFunc)
-binaryComplement1s = Generator("Binary Complement 1s", 4, "1010=", "0101",
-                               binaryComplement1sFunc)
-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)
-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)
-fractionDivision = Generator("Fraction Division", 16, "(a/b)/(c/d)=", "x/y",
-                             divideFractionsFunc)
-intMatrix22Multiplication = Generator("Integer Multiplication with 2x2 Matrix",
-                                      17, "k * [[a,b],[c,d]]=",
-                                      "[[k*a,k*b],[k*c,k*d]]",
-                                      multiplyIntToMatrix22)
-areaOfTriangle = Generator("Area of Triangle", 18,
-                           "Area of Triangle with side lengths a, b, c = ",
-                           "area", areaOfTriangleFunc)
-doesTriangleExist = Generator("Triangle exists check", 19,
-                              "Does triangle with sides a, b and c exist?",
-                              "Yes/No", isTriangleValidFunc)
-midPointOfTwoPoint = Generator("Midpoint of the two point", 20,
-                               "((X1,Y1),(X2,Y2))=", "((X1+X2)/2,(Y1+Y2)/2)",
-                               MidPointOfTwoPointFunc)
-factoring = Generator("Factoring Quadratic", 21, "x^2+(x1+x2)+x1*x2",
-                      "(x-x1)(x-x2)", factoringFunc)
-thirdAngleOfTriangle = Generator("Third Angle of Triangle", 22,
-                                 "Third Angle of the triangle = ", "angle3",
-                                 thirdAngleOfTriangleFunc)
-systemOfEquations = Generator("Solve a System of Equations in R^2", 23,
-                              "2x + 5y = 13, -3x - 3y = -6", "x = -1, y = 3",
-                              systemOfEquationsFunc)
-distance2Point = Generator("Distance between 2 points", 24,
-                           "Find the distance between (x1,y1) and (x2,y2)",
-                           "sqrt(distanceSquared)", distanceTwoPointsFunc)
-pythagoreanTheorem = Generator(
-    "Pythagorean Theorem", 25,
-    "The hypotenuse of a right triangle given the other two lengths a and b = ",
-    "hypotenuse", pythagoreanTheoremFunc)
-# 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)
-primeFactors = Generator("Prime Factorisation", 27, "Prime Factors of a =",
-                         "[b, c, d, ...]", primeFactorsFunc)
-fractionMultiplication = Generator("Fraction Multiplication", 28,
-                                   "(a/b)*(c/d)=", "x/y",
-                                   multiplyFractionsFunc)
-angleRegularPolygon = Generator(
-    "Angle of a Regular Polygon", 29,
-    "Find the angle of a regular polygon with 6 sides", "120",
-    regularPolygonAngleFunc)
-combinations = Generator(
-    "Combinations of Objects", 30,
-    "Combinations available for picking 4 objects at a time from 6 distinct objects =",
-    " 15", combinationsFunc)
-factorial = Generator("Factorial", 31, "a! = ", "b", factorialFunc)
-surfaceAreaCubeGen = Generator("Surface Area of Cube", 32,
-                               "Surface area of cube with side a units is",
-                               "b units^2", surfaceAreaCube)
-surfaceAreaCuboidGen = Generator(
-    "Surface Area of Cuboid", 33,
-    "Surface area of cuboid with sides = a units, b units, c units is",
-    "d units^2", surfaceAreaCuboid)
-surfaceAreaCylinderGen = Generator(
-    "Surface Area of Cylinder", 34,
-    "Surface area of cylinder with height = a units and radius = b units is",
-    "c units^2", surfaceAreaCylinder)
-volumeCubeGen = Generator("Volum of Cube", 35,
-                          "Volume of cube with side a units is", "b units^3",
-                          volumeCube)
-volumeCuboidGen = Generator(
-    "Volume of Cuboid", 36,
-    "Volume of cuboid with sides = a units, b units, c units is", "d units^3",
-    volumeCuboid)
-volumeCylinderGen = Generator(
-    "Volume of cylinder", 37,
-    "Volume of cylinder with height = a units and radius = b units is",
-    "c units^3", volumeCylinder)
-surfaceAreaConeGen = Generator(
-    "Surface Area of cone", 38,
-    "Surface area of cone with height = a units and radius = b units is",
-    "c units^2", surfaceAreaCone)
-volumeConeGen = Generator(
-    "Volume of cone", 39,
-    "Volume of cone with height = a units and radius = b units is",
-    "c units^3", volumeCone)
-commonFactors = Generator("Common Factors", 40,
-                          "Common Factors of {a} and {b} = ", "[c, d, ...]",
-                          commonFactorsFunc)
-intersectionOfTwoLines = Generator(
-    "Intersection of Two Lines", 41,
-    "Find the point of intersection of the two lines: y = m1*x + b1 and y = m2*x + b2",
-    "(x, y)", intersectionOfTwoLinesFunc)
-permutations = Generator(
-    "Permutations", 42,
-    "Total permutations of 4 objects at a time from 10 objects is", "5040",
-    permutationFunc)
-vectorCross = Generator("Cross Product of 2 Vectors", 43, "a X b = ", "c",
-                        vectorCrossFunc)
-compareFractions = Generator(
-    "Compare Fractions", 44,
-    "Which symbol represents the comparison between a/b and c/d?", ">/</=",
-    compareFractionsFunc)
-simpleInterest = Generator(
-    "Simple Interest", 45,
-    "Simple interest for a principle amount of a dollars, b% rate of interest and for a time period of c years is = ",
-    "d dollars", simpleInterestFunc)
-matrixMultiplication = Generator("Multiplication of two matrices", 46,
-                                 "Multiply two matrices A and B", "C",
-                                 matrixMultiplicationFunc)
-CubeRoot = Generator("Cube Root", 47, "Cuberoot of a upto 2 decimal places is",
-                     "b", cubeRootFunc)
-powerRuleIntegration = Generator("Power Rule Integration", 48, "nx^m=",
-                                 "(n/m)x^(m+1)", powerRuleIntegrationFunc)
-fourthAngleOfQuadrilateral = Generator(
-    "Fourth Angle of Quadrilateral", 49,
-    "Fourth angle of Quadrilateral with angles a,b,c =", "angle4",
-    fourthAngleOfQuadriFunc)
-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)
-diceSumProbability = Generator(
-    "Probability of a certain sum appearing on faces of dice", 52,
-    "If n dices are rolled then probabilty of getting sum of x is =", "z",
-    DiceSumProbFunc)
-exponentiation = Generator("Exponentiation", 53, "a^b = ", "c",
-                           exponentiationFunc)
-confidenceInterval = Generator("Confidence interval For sample S", 54,
-                               "With X% confidence", "is (A,B)",
-                               confidenceIntervalFunc)
-surdsComparison = Generator("Comparing surds", 55,
-                            "Fill in the blanks a^(1/b) _ c^(1/d)", "</>/=",
-                            surdsComparisonFunc)
-fibonacciSeries = Generator(
-    "Fibonacci Series", 56, "fibonacci series of first a numbers",
-    "prints the fibonacci series starting from 0 to a", fibonacciSeriesFunc)
-basicTrigonometry = Generator("Trigonometric Values", 57, "What is sin(X)?",
-                              "ans", basicTrigonometryFunc)
-sumOfAnglesOfPolygon = Generator("Sum of Angles of Polygon", 58,
-                                 "Sum of angles of polygon with n sides = ",
-                                 "sum", sumOfAnglesOfPolygonFunc)
-dataSummary = Generator("Mean,Standard Deviation,Variance", 59, "a,b,c",
-                        "Mean:a+b+c/3,Std,Var", dataSummaryFunc)
-surfaceAreaSphereGen = Generator(
-    "Surface Area of Sphere", 60,
-    "Surface area of sphere with radius = a units is", "d units^2",
-    surfaceAreaSphere)
-volumeSphere = Generator("Volume of Sphere", 61,
-                         "Volume of sphere with radius r m = ",
-                         "(4*pi/3)*r*r*r", volumeSphereFunc)
-nthFibonacciNumberGen = Generator("nth Fibonacci number", 62,
-                                  "What is the nth Fibonacci number", "Fn",
-                                  nthFibonacciNumberFunc)
-profitLossPercent = Generator(
-    "Profit or Loss Percent", 63,
-    "Profit/ Loss percent when CP = cp and SP = sp is: ", "percent",
-    profitLossPercentFunc)
-binaryToHex = Generator("Binary to Hexidecimal", 64, "Hexidecimal of a=", "b",
-                        binaryToHexFunc)
-complexNumMultiply = Generator("Multiplication of 2 complex numbers", 65,
-                               "(x + j) (y + j) = ", "xy + xj + yj -1",
-                               multiplyComplexNumbersFunc)
-geometricprogression = Generator(
-    "Geometric Progression", 66,
-    "Initial value,Common Ratio,nth Term,Sum till nth term =",
-    "a,r,ar^n-1,sum(ar^n-1", geomProgrFunc)
-geometricMean = Generator("Geometric Mean of N Numbers", 67,
-                          "Geometric mean of n numbers A1 , A2 , ... , An = ",
-                          "(A1*A2*...An)^(1/n) = ans", geometricMeanFunc)
-harmonicMean = Generator("Harmonic Mean of N Numbers", 68,
-                         "Harmonic mean of n numbers A1 , A2 , ... , An = ",
-                         " n/((1/A1) + (1/A2) + ... + (1/An)) = ans",
-                         harmonicMeanFunc)
-eucldianNorm = Generator("Euclidian norm or L2 norm of a vector", 69,
-                         "Euclidian Norm of a vector V:[v1, v2, ......., vn]",
-                         "sqrt(v1^2 + v2^2 ........ +vn^2)", euclidianNormFunc)
-angleBtwVectors = Generator(
-    "Angle between 2 vectors", 70,
-    "Angle Between 2 vectors V1=[v11, v12, ..., v1n] and V2=[v21, v22, ....., v2n]",
-    "V1.V2 / (euclidNorm(V1)*euclidNorm(V2))", angleBtwVectorsFunc)
-absoluteDifference = Generator(
-    "Absolute difference between two numbers", 71,
-    "Absolute difference betweeen two numbers a and b =", "|a-b|",
-    absoluteDifferenceFunc)
-vectorDot = Generator("Dot Product of 2 Vectors", 72, "a . b = ", "c",
-                      vectorDotFunc)
-binary2sComplement = Generator("Binary 2's Complement", 73,
-                               "2's complement of 11010110 =", "101010",
-                               binary2sComplementFunc)
-invertmatrix = Generator("Inverse of a Matrix", 74, "Inverse of a matrix A is",
-                         "A^(-1)", matrixInversion)
-sectorArea = Generator("Area of a Sector", 75,
-                       "Area of a sector with radius, r and angle, a ", "Area",
-                       sectorAreaFunc)
-meanMedian = Generator("Mean and Median", 76,
-                       "Mean and median of given set of numbers",
-                       "Mean, Median", meanMedianFunc)
-intMatrix22determinant = Generator("Determinant to 2x2 Matrix", 77,
-                                   "Det([[a,b],[c,d]]) =", " a * d - b * c",
-                                   determinantToMatrix22)
-compoundInterest = Generator(
-    "Compound Interest", 78,
-    "Compound interest for a principle amount of p dollars, r% rate of interest and for a time period of t years with n times compounded annually is = ",
-    "A dollars", compoundInterestFunc)
-decimalToHexadeci = Generator("Decimal to Hexadecimal", 79, "Binary of a=",
-                              "b", deciToHexaFunc)
-percentage = Generator("Percentage of a number", 80, "What is a% of b?",
-                       "percentage", percentageFunc)
-celsiusToFahrenheit = Generator("Celsius To Fahrenheit", 81, "(C +(9/5))+32=", "F", celsiustofahrenheitFunc)
-quotientOfPowerSameBase = Generator("Quotient of Powers with Same Base", 82,
-                                "6^4 / 6^2 = 6^(4-2) = 6^2", "36", quotientofpowersamebaseFunc)
-quotientOfPowerSamePower = Generator("Quotient of Powers with Same Power", 83,
-                                "6^4 / 3^4 = (6/3)^4 = 2^4", "16", quotientofpowersamepowerFunc)