From b1a06816dd44432f51c39059d2c7379a069a1252 Mon Sep 17 00:00:00 2001
From: helplessThor <66440538+helplessThor@users.noreply.github.com>
Date: Sat, 17 Oct 2020 15:11:18 +0530
Subject: [PATCH 1/4] Update mathgen.py

Compound Interest added
---
 mathgenerator/mathgen.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/mathgenerator/mathgen.py b/mathgenerator/mathgen.py
index 1041a55..f986d76 100644
--- a/mathgenerator/mathgen.py
+++ b/mathgenerator/mathgen.py
@@ -637,6 +637,15 @@ def simpleInterestFunc(maxPrinciple = 10000, maxRate = 10, maxTime = 10):
         problem = "Simple interest for a principle amount of " + str(a) +" dollars, " + str(b) + "% rate of interest and for a time period of " + str(c) + " years is = "
         solution = round(d, 2)
         return problem, solution
+def compoundInterestFunc(maxPrinciple = 10000, maxRate = 10, maxTime = 10, maxPeriod = ):
+    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
 
 def matrixMultiplicationFunc(maxVal=100):
     m= random.randint(2, 10)

From 76c8d0e5609ba471e49f6c205b247494733157e2 Mon Sep 17 00:00:00 2001
From: helplessThor <66440538+helplessThor@users.noreply.github.com>
Date: Mon, 19 Oct 2020 19:33:00 +0530
Subject: [PATCH 2/4] Add files via upload

---
 mathgenerator/funcs/BinaryToDecimalFunc.py    | 12 +++
 mathgenerator/funcs/DecimalToBinaryFunc.py    | 11 +++
 mathgenerator/funcs/DiceSumProbFunc.py        | 25 ++++++
 mathgenerator/funcs/MidPointOfTwoPointFunc.py | 12 +++
 mathgenerator/funcs/__init__.py               | 79 +++++++++++++++++++
 mathgenerator/funcs/absoluteDifferenceFunc.py | 10 +++
 mathgenerator/funcs/additionFunc.py           | 10 +++
 mathgenerator/funcs/angleBtwVectorsFunc.py    | 16 ++++
 mathgenerator/funcs/areaOfTriangleFunc.py     | 14 ++++
 mathgenerator/funcs/basicAlgebraFunc.py       | 25 ++++++
 mathgenerator/funcs/basicTrigonometryFunc.py  | 14 ++++
 mathgenerator/funcs/binary2sComplement.py     | 26 ++++++
 mathgenerator/funcs/binaryComplement1sFunc.py | 15 ++++
 mathgenerator/funcs/binaryToHexFunc.py        | 11 +++
 mathgenerator/funcs/combinationsFunc.py       | 19 +++++
 mathgenerator/funcs/commonFactorsFunc.py      | 24 ++++++
 mathgenerator/funcs/compareFractionsFunc.py   | 26 ++++++
 mathgenerator/funcs/confidenceIntervalFunc.py | 30 +++++++
 mathgenerator/funcs/cubeRootFunc.py           | 10 +++
 mathgenerator/funcs/dataSummaryFunc.py        | 26 ++++++
 mathgenerator/funcs/distanceTwoPointsFunc.py  | 14 ++++
 mathgenerator/funcs/divideFractionsFunc.py    | 32 ++++++++
 mathgenerator/funcs/divisionFunc.py           | 11 +++
 mathgenerator/funcs/divisionToIntFunc.py      | 13 +++
 mathgenerator/funcs/euclidianNormFunc.py      |  7 ++
 mathgenerator/funcs/exponentiationFunc.py     | 10 +++
 mathgenerator/funcs/factorialFunc.py          | 15 ++++
 mathgenerator/funcs/factoringFunc.py          | 29 +++++++
 mathgenerator/funcs/fibonacciSeriesFunc.py    | 21 +++++
 .../funcs/fourthAngleOfQuadriFunc.py          | 14 ++++
 mathgenerator/funcs/gcdFunc.py                | 12 +++
 mathgenerator/funcs/geomProgrFunc.py          | 15 ++++
 mathgenerator/funcs/geometricMeanFunc.py      | 27 +++++++
 mathgenerator/funcs/harmonicMeanFunc.py       | 28 +++++++
 mathgenerator/funcs/hcfFunc.py                | 11 +++
 .../funcs/intersectionOfTwoLinesFunc.py       | 62 +++++++++++++++
 mathgenerator/funcs/isTriangleValidFunc.py    | 19 +++++
 mathgenerator/funcs/lcmFunc.py                | 17 ++++
 mathgenerator/funcs/linearEquationsFunc.py    | 25 ++++++
 mathgenerator/funcs/logFunc.py                | 12 +++
 mathgenerator/funcs/matrixInversion.py        | 69 ++++++++++++++++
 .../funcs/matrixMultiplicationFunc.py         | 51 ++++++++++++
 mathgenerator/funcs/moduloFunc.py             | 11 +++
 mathgenerator/funcs/multiplicationFunc.py     | 11 +++
 .../funcs/multiplyComplexNumbersFunc.py       |  9 +++
 mathgenerator/funcs/multiplyFractionsFunc.py  | 32 ++++++++
 mathgenerator/funcs/multiplyIntToMatrix22.py  | 13 +++
 mathgenerator/funcs/nthFibonacciNumberFunc.py | 10 +++
 mathgenerator/funcs/permutationFunc.py        | 10 +++
 .../funcs/powerRuleDifferentiationFunc.py     | 18 +++++
 .../funcs/powerRuleIntegrationFunc.py         | 20 +++++
 mathgenerator/funcs/primeFactorsFunc.py       | 22 ++++++
 mathgenerator/funcs/profitLossPercentFunc.py  | 16 ++++
 mathgenerator/funcs/pythagoreanTheoremFunc.py | 11 +++
 mathgenerator/funcs/quadraticEquation.py      | 12 +++
 .../funcs/regularPolygonAngleFunc.py          | 10 +++
 mathgenerator/funcs/simpleInterestFunc.py     | 12 +++
 mathgenerator/funcs/squareFunc.py             | 10 +++
 mathgenerator/funcs/squareRootFunc.py         | 10 +++
 mathgenerator/funcs/subtractionFunc.py        | 11 +++
 .../funcs/sumOfAnglesOfPolygonFunc.py         | 10 +++
 mathgenerator/funcs/surdsComparisonFunc.py    | 17 ++++
 mathgenerator/funcs/surfaceAreaCone.py        | 13 +++
 mathgenerator/funcs/surfaceAreaCube.py        |  9 +++
 mathgenerator/funcs/surfaceAreaCuboid.py      | 12 +++
 mathgenerator/funcs/surfaceAreaCylinder.py    | 11 +++
 mathgenerator/funcs/surfaceAreaSphere.py      | 10 +++
 mathgenerator/funcs/systemOfEquationsFunc.py  | 45 +++++++++++
 .../funcs/thirdAngleOfTriangleFunc.py         | 11 +++
 mathgenerator/funcs/vectorCrossFunc.py        | 13 +++
 mathgenerator/funcs/vectorDotFunc.py          | 11 +++
 mathgenerator/funcs/volumeCone.py             | 11 +++
 mathgenerator/funcs/volumeCube.py             | 10 +++
 mathgenerator/funcs/volumeCuboid.py           | 12 +++
 mathgenerator/funcs/volumeCylinder.py         | 11 +++
 mathgenerator/funcs/volumeSphereFunc.py       | 10 +++
 76 files changed, 1393 insertions(+)
 create mode 100644 mathgenerator/funcs/BinaryToDecimalFunc.py
 create mode 100644 mathgenerator/funcs/DecimalToBinaryFunc.py
 create mode 100644 mathgenerator/funcs/DiceSumProbFunc.py
 create mode 100644 mathgenerator/funcs/MidPointOfTwoPointFunc.py
 create mode 100644 mathgenerator/funcs/__init__.py
 create mode 100644 mathgenerator/funcs/absoluteDifferenceFunc.py
 create mode 100644 mathgenerator/funcs/additionFunc.py
 create mode 100644 mathgenerator/funcs/angleBtwVectorsFunc.py
 create mode 100644 mathgenerator/funcs/areaOfTriangleFunc.py
 create mode 100644 mathgenerator/funcs/basicAlgebraFunc.py
 create mode 100644 mathgenerator/funcs/basicTrigonometryFunc.py
 create mode 100644 mathgenerator/funcs/binary2sComplement.py
 create mode 100644 mathgenerator/funcs/binaryComplement1sFunc.py
 create mode 100644 mathgenerator/funcs/binaryToHexFunc.py
 create mode 100644 mathgenerator/funcs/combinationsFunc.py
 create mode 100644 mathgenerator/funcs/commonFactorsFunc.py
 create mode 100644 mathgenerator/funcs/compareFractionsFunc.py
 create mode 100644 mathgenerator/funcs/confidenceIntervalFunc.py
 create mode 100644 mathgenerator/funcs/cubeRootFunc.py
 create mode 100644 mathgenerator/funcs/dataSummaryFunc.py
 create mode 100644 mathgenerator/funcs/distanceTwoPointsFunc.py
 create mode 100644 mathgenerator/funcs/divideFractionsFunc.py
 create mode 100644 mathgenerator/funcs/divisionFunc.py
 create mode 100644 mathgenerator/funcs/divisionToIntFunc.py
 create mode 100644 mathgenerator/funcs/euclidianNormFunc.py
 create mode 100644 mathgenerator/funcs/exponentiationFunc.py
 create mode 100644 mathgenerator/funcs/factorialFunc.py
 create mode 100644 mathgenerator/funcs/factoringFunc.py
 create mode 100644 mathgenerator/funcs/fibonacciSeriesFunc.py
 create mode 100644 mathgenerator/funcs/fourthAngleOfQuadriFunc.py
 create mode 100644 mathgenerator/funcs/gcdFunc.py
 create mode 100644 mathgenerator/funcs/geomProgrFunc.py
 create mode 100644 mathgenerator/funcs/geometricMeanFunc.py
 create mode 100644 mathgenerator/funcs/harmonicMeanFunc.py
 create mode 100644 mathgenerator/funcs/hcfFunc.py
 create mode 100644 mathgenerator/funcs/intersectionOfTwoLinesFunc.py
 create mode 100644 mathgenerator/funcs/isTriangleValidFunc.py
 create mode 100644 mathgenerator/funcs/lcmFunc.py
 create mode 100644 mathgenerator/funcs/linearEquationsFunc.py
 create mode 100644 mathgenerator/funcs/logFunc.py
 create mode 100644 mathgenerator/funcs/matrixInversion.py
 create mode 100644 mathgenerator/funcs/matrixMultiplicationFunc.py
 create mode 100644 mathgenerator/funcs/moduloFunc.py
 create mode 100644 mathgenerator/funcs/multiplicationFunc.py
 create mode 100644 mathgenerator/funcs/multiplyComplexNumbersFunc.py
 create mode 100644 mathgenerator/funcs/multiplyFractionsFunc.py
 create mode 100644 mathgenerator/funcs/multiplyIntToMatrix22.py
 create mode 100644 mathgenerator/funcs/nthFibonacciNumberFunc.py
 create mode 100644 mathgenerator/funcs/permutationFunc.py
 create mode 100644 mathgenerator/funcs/powerRuleDifferentiationFunc.py
 create mode 100644 mathgenerator/funcs/powerRuleIntegrationFunc.py
 create mode 100644 mathgenerator/funcs/primeFactorsFunc.py
 create mode 100644 mathgenerator/funcs/profitLossPercentFunc.py
 create mode 100644 mathgenerator/funcs/pythagoreanTheoremFunc.py
 create mode 100644 mathgenerator/funcs/quadraticEquation.py
 create mode 100644 mathgenerator/funcs/regularPolygonAngleFunc.py
 create mode 100644 mathgenerator/funcs/simpleInterestFunc.py
 create mode 100644 mathgenerator/funcs/squareFunc.py
 create mode 100644 mathgenerator/funcs/squareRootFunc.py
 create mode 100644 mathgenerator/funcs/subtractionFunc.py
 create mode 100644 mathgenerator/funcs/sumOfAnglesOfPolygonFunc.py
 create mode 100644 mathgenerator/funcs/surdsComparisonFunc.py
 create mode 100644 mathgenerator/funcs/surfaceAreaCone.py
 create mode 100644 mathgenerator/funcs/surfaceAreaCube.py
 create mode 100644 mathgenerator/funcs/surfaceAreaCuboid.py
 create mode 100644 mathgenerator/funcs/surfaceAreaCylinder.py
 create mode 100644 mathgenerator/funcs/surfaceAreaSphere.py
 create mode 100644 mathgenerator/funcs/systemOfEquationsFunc.py
 create mode 100644 mathgenerator/funcs/thirdAngleOfTriangleFunc.py
 create mode 100644 mathgenerator/funcs/vectorCrossFunc.py
 create mode 100644 mathgenerator/funcs/vectorDotFunc.py
 create mode 100644 mathgenerator/funcs/volumeCone.py
 create mode 100644 mathgenerator/funcs/volumeCube.py
 create mode 100644 mathgenerator/funcs/volumeCuboid.py
 create mode 100644 mathgenerator/funcs/volumeCylinder.py
 create mode 100644 mathgenerator/funcs/volumeSphereFunc.py

diff --git a/mathgenerator/funcs/BinaryToDecimalFunc.py b/mathgenerator/funcs/BinaryToDecimalFunc.py
new file mode 100644
index 0000000..27b165d
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/DecimalToBinaryFunc.py b/mathgenerator/funcs/DecimalToBinaryFunc.py
new file mode 100644
index 0000000..8df2d8a
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/DiceSumProbFunc.py b/mathgenerator/funcs/DiceSumProbFunc.py
new file mode 100644
index 0000000..2180ee4
--- /dev/null
+++ b/mathgenerator/funcs/DiceSumProbFunc.py
@@ -0,0 +1,25 @@
+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
diff --git a/mathgenerator/funcs/MidPointOfTwoPointFunc.py b/mathgenerator/funcs/MidPointOfTwoPointFunc.py
new file mode 100644
index 0000000..3c9202a
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/__init__.py b/mathgenerator/funcs/__init__.py
new file mode 100644
index 0000000..f054a11
--- /dev/null
+++ b/mathgenerator/funcs/__init__.py
@@ -0,0 +1,79 @@
+import random
+import math
+import fractions
+
+from .additionFunc 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 *
diff --git a/mathgenerator/funcs/absoluteDifferenceFunc.py b/mathgenerator/funcs/absoluteDifferenceFunc.py
new file mode 100644
index 0000000..d578d19
--- /dev/null
+++ b/mathgenerator/funcs/absoluteDifferenceFunc.py
@@ -0,0 +1,10 @@
+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
\ No newline at end of file
diff --git a/mathgenerator/funcs/additionFunc.py b/mathgenerator/funcs/additionFunc.py
new file mode 100644
index 0000000..30dfefe
--- /dev/null
+++ b/mathgenerator/funcs/additionFunc.py
@@ -0,0 +1,10 @@
+from  .__init__ import *
+
+
+def additionFunc(maxSum=99, maxAddend=50):
+    a = random.randint(0, maxAddend)
+    b = random.randint(0, min((maxSum - a), maxAddend))  # The highest value of b will be no higher than the maxsum minus the first number and no higher than the maxAddend as well
+    c = a + b
+    problem = str(a) + "+" + str(b) + "="
+    solution = str(c)
+    return problem, solution
diff --git a/mathgenerator/funcs/angleBtwVectorsFunc.py b/mathgenerator/funcs/angleBtwVectorsFunc.py
new file mode 100644
index 0000000..bd2d0b5
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/areaOfTriangleFunc.py b/mathgenerator/funcs/areaOfTriangleFunc.py
new file mode 100644
index 0000000..a5e1250
--- /dev/null
+++ b/mathgenerator/funcs/areaOfTriangleFunc.py
@@ -0,0 +1,14 @@
+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
diff --git a/mathgenerator/funcs/basicAlgebraFunc.py b/mathgenerator/funcs/basicAlgebraFunc.py
new file mode 100644
index 0000000..939ac5e
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/basicTrigonometryFunc.py b/mathgenerator/funcs/basicTrigonometryFunc.py
new file mode 100644
index 0000000..dd4fe5d
--- /dev/null
+++ b/mathgenerator/funcs/basicTrigonometryFunc.py
@@ -0,0 +1,14 @@
+from  .__init__ import *
+
+
+def basicTrigonometryFunc(angles=[0,30,45,60,90],functions=["sin","cos","tan"]): #Handles degrees in quadrant one
+    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
diff --git a/mathgenerator/funcs/binary2sComplement.py b/mathgenerator/funcs/binary2sComplement.py
new file mode 100644
index 0000000..f51b797
--- /dev/null
+++ b/mathgenerator/funcs/binary2sComplement.py
@@ -0,0 +1,26 @@
+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 == True:
+        answer.insert(0, '1')
+
+    problem = "2's complement of " + question + " ="
+    solution = ''.join(answer).lstrip('0')
+    return problem, solution
\ No newline at end of file
diff --git a/mathgenerator/funcs/binaryComplement1sFunc.py b/mathgenerator/funcs/binaryComplement1sFunc.py
new file mode 100644
index 0000000..2568303
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/binaryToHexFunc.py b/mathgenerator/funcs/binaryToHexFunc.py
new file mode 100644
index 0000000..0f3e962
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/combinationsFunc.py b/mathgenerator/funcs/combinationsFunc.py
new file mode 100644
index 0000000..79390a6
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/commonFactorsFunc.py b/mathgenerator/funcs/commonFactorsFunc.py
new file mode 100644
index 0000000..633abb3
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/compareFractionsFunc.py b/mathgenerator/funcs/compareFractionsFunc.py
new file mode 100644
index 0000000..d0d08a4
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/confidenceIntervalFunc.py b/mathgenerator/funcs/confidenceIntervalFunc.py
new file mode 100644
index 0000000..32bd26a
--- /dev/null
+++ b/mathgenerator/funcs/confidenceIntervalFunc.py
@@ -0,0 +1,30 @@
+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
diff --git a/mathgenerator/funcs/cubeRootFunc.py b/mathgenerator/funcs/cubeRootFunc.py
new file mode 100644
index 0000000..c9de53c
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/dataSummaryFunc.py b/mathgenerator/funcs/dataSummaryFunc.py
new file mode 100644
index 0000000..016737c
--- /dev/null
+++ b/mathgenerator/funcs/dataSummaryFunc.py
@@ -0,0 +1,26 @@
+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
diff --git a/mathgenerator/funcs/distanceTwoPointsFunc.py b/mathgenerator/funcs/distanceTwoPointsFunc.py
new file mode 100644
index 0000000..1f48f90
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/divideFractionsFunc.py b/mathgenerator/funcs/divideFractionsFunc.py
new file mode 100644
index 0000000..abfbec6
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/divisionFunc.py b/mathgenerator/funcs/divisionFunc.py
new file mode 100644
index 0000000..60af33d
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/divisionToIntFunc.py b/mathgenerator/funcs/divisionToIntFunc.py
new file mode 100644
index 0000000..d5f3cfd
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/euclidianNormFunc.py b/mathgenerator/funcs/euclidianNormFunc.py
new file mode 100644
index 0000000..f66329e
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/exponentiationFunc.py b/mathgenerator/funcs/exponentiationFunc.py
new file mode 100644
index 0000000..4ff1ba1
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/factorialFunc.py b/mathgenerator/funcs/factorialFunc.py
new file mode 100644
index 0000000..ac4536c
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/factoringFunc.py b/mathgenerator/funcs/factoringFunc.py
new file mode 100644
index 0000000..c52482f
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/mathgenerator/funcs/fibonacciSeriesFunc.py b/mathgenerator/funcs/fibonacciSeriesFunc.py
new file mode 100644
index 0000000..42de00d
--- /dev/null
+++ b/mathgenerator/funcs/fibonacciSeriesFunc.py
@@ -0,0 +1,21 @@
+from .__init__ import *
+
+
+def fibonacciSeriesFunc(minNo=1):
+    n = random.randint(minNo,20)
+
+    def createFibList(n):
+        l=[]
+        for i in range(n):
+            if i<2:
+                l.append(i)
+            else:
+                val = l[i-1]+l[i-2]
+                l.append(val)
+        return l
+
+    fibList=createFibList(n)
+    
+    problem = "The Fibonacci Series of the first "+str(n)+" numbers is ?"
+    solution = fibList
+    return problem,solution
diff --git a/mathgenerator/funcs/fourthAngleOfQuadriFunc.py b/mathgenerator/funcs/fourthAngleOfQuadriFunc.py
new file mode 100644
index 0000000..d183e17
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/gcdFunc.py b/mathgenerator/funcs/gcdFunc.py
new file mode 100644
index 0000000..505c7fb
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/geomProgrFunc.py b/mathgenerator/funcs/geomProgrFunc.py
new file mode 100644
index 0000000..3e3ad5c
--- /dev/null
+++ b/mathgenerator/funcs/geomProgrFunc.py
@@ -0,0 +1,15 @@
+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
diff --git a/mathgenerator/funcs/geometricMeanFunc.py b/mathgenerator/funcs/geometricMeanFunc.py
new file mode 100644
index 0000000..05ded2b
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/harmonicMeanFunc.py b/mathgenerator/funcs/harmonicMeanFunc.py
new file mode 100644
index 0000000..035273f
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/hcfFunc.py b/mathgenerator/funcs/hcfFunc.py
new file mode 100644
index 0000000..40be783
--- /dev/null
+++ b/mathgenerator/funcs/hcfFunc.py
@@ -0,0 +1,11 @@
+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
diff --git a/mathgenerator/funcs/intersectionOfTwoLinesFunc.py b/mathgenerator/funcs/intersectionOfTwoLinesFunc.py
new file mode 100644
index 0000000..96f681d
--- /dev/null
+++ b/mathgenerator/funcs/intersectionOfTwoLinesFunc.py
@@ -0,0 +1,62 @@
+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
diff --git a/mathgenerator/funcs/isTriangleValidFunc.py b/mathgenerator/funcs/isTriangleValidFunc.py
new file mode 100644
index 0000000..a80a05d
--- /dev/null
+++ b/mathgenerator/funcs/isTriangleValidFunc.py
@@ -0,0 +1,19 @@
+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
diff --git a/mathgenerator/funcs/lcmFunc.py b/mathgenerator/funcs/lcmFunc.py
new file mode 100644
index 0000000..af2ee41
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/linearEquationsFunc.py b/mathgenerator/funcs/linearEquationsFunc.py
new file mode 100644
index 0000000..4aa1fba
--- /dev/null
+++ b/mathgenerator/funcs/linearEquationsFunc.py
@@ -0,0 +1,25 @@
+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
diff --git a/mathgenerator/funcs/logFunc.py b/mathgenerator/funcs/logFunc.py
new file mode 100644
index 0000000..8d16214
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/matrixInversion.py b/mathgenerator/funcs/matrixInversion.py
new file mode 100644
index 0000000..822cb83
--- /dev/null
+++ b/mathgenerator/funcs/matrixInversion.py
@@ -0,0 +1,69 @@
+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
diff --git a/mathgenerator/funcs/matrixMultiplicationFunc.py b/mathgenerator/funcs/matrixMultiplicationFunc.py
new file mode 100644
index 0000000..eeaa265
--- /dev/null
+++ b/mathgenerator/funcs/matrixMultiplicationFunc.py
@@ -0,0 +1,51 @@
+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)
+
+    problem = f"Multiply \n{a_string}\n and \n\n{b_string}"  # consider using a, b instead of a_string, b_string if the problem doesn't look right
+    solution = matrixMultiplicationFuncHelper(res)
+    return problem, solution
+
+def matrixMultiplicationFuncHelper(inp):
+    m = len(inp)
+    n = len(inp[0])
+
+    string = "[["
+    for i in range(m):
+        for j in range(n):
+            string += f"{inp[i][j]: 6d}"
+            string += ", "if j < n-1 else ""
+        string += "]\n [" if i < m-1 else ""
+    string += "]]"
+        
+    return string
\ No newline at end of file
diff --git a/mathgenerator/funcs/moduloFunc.py b/mathgenerator/funcs/moduloFunc.py
new file mode 100644
index 0000000..71f1421
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/multiplicationFunc.py b/mathgenerator/funcs/multiplicationFunc.py
new file mode 100644
index 0000000..00ebb26
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/multiplyComplexNumbersFunc.py b/mathgenerator/funcs/multiplyComplexNumbersFunc.py
new file mode 100644
index 0000000..f959d4d
--- /dev/null
+++ b/mathgenerator/funcs/multiplyComplexNumbersFunc.py
@@ -0,0 +1,9 @@
+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
diff --git a/mathgenerator/funcs/multiplyFractionsFunc.py b/mathgenerator/funcs/multiplyFractionsFunc.py
new file mode 100644
index 0000000..14614d6
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/multiplyIntToMatrix22.py b/mathgenerator/funcs/multiplyIntToMatrix22.py
new file mode 100644
index 0000000..120c202
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/nthFibonacciNumberFunc.py b/mathgenerator/funcs/nthFibonacciNumberFunc.py
new file mode 100644
index 0000000..023a007
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/permutationFunc.py b/mathgenerator/funcs/permutationFunc.py
new file mode 100644
index 0000000..ffae44e
--- /dev/null
+++ b/mathgenerator/funcs/permutationFunc.py
@@ -0,0 +1,10 @@
+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
diff --git a/mathgenerator/funcs/powerRuleDifferentiationFunc.py b/mathgenerator/funcs/powerRuleDifferentiationFunc.py
new file mode 100644
index 0000000..9dac2db
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/powerRuleIntegrationFunc.py b/mathgenerator/funcs/powerRuleIntegrationFunc.py
new file mode 100644
index 0000000..112f5b5
--- /dev/null
+++ b/mathgenerator/funcs/powerRuleIntegrationFunc.py
@@ -0,0 +1,20 @@
+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
diff --git a/mathgenerator/funcs/primeFactorsFunc.py b/mathgenerator/funcs/primeFactorsFunc.py
new file mode 100644
index 0000000..5e645d2
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/profitLossPercentFunc.py b/mathgenerator/funcs/profitLossPercentFunc.py
new file mode 100644
index 0000000..05a3653
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/mathgenerator/funcs/pythagoreanTheoremFunc.py b/mathgenerator/funcs/pythagoreanTheoremFunc.py
new file mode 100644
index 0000000..2776592
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/quadraticEquation.py b/mathgenerator/funcs/quadraticEquation.py
new file mode 100644
index 0000000..98f895e
--- /dev/null
+++ b/mathgenerator/funcs/quadraticEquation.py
@@ -0,0 +1,12 @@
+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
diff --git a/mathgenerator/funcs/regularPolygonAngleFunc.py b/mathgenerator/funcs/regularPolygonAngleFunc.py
new file mode 100644
index 0000000..569d2d5
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/simpleInterestFunc.py b/mathgenerator/funcs/simpleInterestFunc.py
new file mode 100644
index 0000000..de997d0
--- /dev/null
+++ b/mathgenerator/funcs/simpleInterestFunc.py
@@ -0,0 +1,12 @@
+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
diff --git a/mathgenerator/funcs/squareFunc.py b/mathgenerator/funcs/squareFunc.py
new file mode 100644
index 0000000..6384197
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/squareRootFunc.py b/mathgenerator/funcs/squareRootFunc.py
new file mode 100644
index 0000000..87152c8
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/subtractionFunc.py b/mathgenerator/funcs/subtractionFunc.py
new file mode 100644
index 0000000..91c8e74
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/sumOfAnglesOfPolygonFunc.py b/mathgenerator/funcs/sumOfAnglesOfPolygonFunc.py
new file mode 100644
index 0000000..6181e96
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/surdsComparisonFunc.py b/mathgenerator/funcs/surdsComparisonFunc.py
new file mode 100644
index 0000000..161aac3
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/surfaceAreaCone.py b/mathgenerator/funcs/surfaceAreaCone.py
new file mode 100644
index 0000000..8132e7d
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/surfaceAreaCube.py b/mathgenerator/funcs/surfaceAreaCube.py
new file mode 100644
index 0000000..9f9d07f
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/surfaceAreaCuboid.py b/mathgenerator/funcs/surfaceAreaCuboid.py
new file mode 100644
index 0000000..3630abc
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/surfaceAreaCylinder.py b/mathgenerator/funcs/surfaceAreaCylinder.py
new file mode 100644
index 0000000..92035ba
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/surfaceAreaSphere.py b/mathgenerator/funcs/surfaceAreaSphere.py
new file mode 100644
index 0000000..84ce3e1
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/systemOfEquationsFunc.py b/mathgenerator/funcs/systemOfEquationsFunc.py
new file mode 100644
index 0000000..fd28eaf
--- /dev/null
+++ b/mathgenerator/funcs/systemOfEquationsFunc.py
@@ -0,0 +1,45 @@
+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
diff --git a/mathgenerator/funcs/thirdAngleOfTriangleFunc.py b/mathgenerator/funcs/thirdAngleOfTriangleFunc.py
new file mode 100644
index 0000000..688b209
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/vectorCrossFunc.py b/mathgenerator/funcs/vectorCrossFunc.py
new file mode 100644
index 0000000..07ff0b2
--- /dev/null
+++ b/mathgenerator/funcs/vectorCrossFunc.py
@@ -0,0 +1,13 @@
+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
diff --git a/mathgenerator/funcs/vectorDotFunc.py b/mathgenerator/funcs/vectorDotFunc.py
new file mode 100644
index 0000000..0364c65
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/volumeCone.py b/mathgenerator/funcs/volumeCone.py
new file mode 100644
index 0000000..4cd5512
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/volumeCube.py b/mathgenerator/funcs/volumeCube.py
new file mode 100644
index 0000000..e487173
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/volumeCuboid.py b/mathgenerator/funcs/volumeCuboid.py
new file mode 100644
index 0000000..a435784
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/volumeCylinder.py b/mathgenerator/funcs/volumeCylinder.py
new file mode 100644
index 0000000..ecd78da
--- /dev/null
+++ b/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
diff --git a/mathgenerator/funcs/volumeSphereFunc.py b/mathgenerator/funcs/volumeSphereFunc.py
new file mode 100644
index 0000000..618dbd3
--- /dev/null
+++ b/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

From ed7cbc3e6983f496ec257a4e4f456bae55ab9e5a Mon Sep 17 00:00:00 2001
From: helplessThor <66440538+helplessThor@users.noreply.github.com>
Date: Mon, 19 Oct 2020 19:39:34 +0530
Subject: [PATCH 3/4] Create compoundInterestFunc.py

---
 mathgenerator/funcs/compoundInterestFunc.py | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 mathgenerator/funcs/compoundInterestFunc.py

diff --git a/mathgenerator/funcs/compoundInterestFunc.py b/mathgenerator/funcs/compoundInterestFunc.py
new file mode 100644
index 0000000..dec3e54
--- /dev/null
+++ b/mathgenerator/funcs/compoundInterestFunc.py
@@ -0,0 +1,11 @@
+from .__init__ import *
+
+def compoundInterestFunc(maxPrinciple = 10000, maxRate = 10, maxTime = 10, maxPeriod = ):
+    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

From 6d66bf53000da470fdd9a5af91784acb396dac97 Mon Sep 17 00:00:00 2001
From: helplessThor <66440538+helplessThor@users.noreply.github.com>
Date: Mon, 19 Oct 2020 20:17:52 +0530
Subject: [PATCH 4/4] Update mathgen.py

added generator class
---
 mathgenerator/mathgen.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/mathgenerator/mathgen.py b/mathgenerator/mathgen.py
index 3bf1417..1009a28 100644
--- a/mathgenerator/mathgen.py
+++ b/mathgenerator/mathgen.py
@@ -108,4 +108,5 @@ angleBtwVectors=Generator("Angle between 2 vectors", 70, "Angle Between 2 vector
 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)
\ No newline at end of file
+invertmatrix = Generator("Inverse of a Matrix", 74, "Inverse of a matrix A is", "A^(-1)", matrixInversion)
+compoundInterest = Generator("Compound Interest", 75, "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)