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..efb1ce7
--- /dev/null
+++ b/mathgenerator/funcs/__init__.py
@@ -0,0 +1,73 @@
+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 *
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/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/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/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/matrixMultiplicationFunc.py b/mathgenerator/funcs/matrixMultiplicationFunc.py
new file mode 100644
index 0000000..de69218
--- /dev/null
+++ b/mathgenerator/funcs/matrixMultiplicationFunc.py
@@ -0,0 +1,50 @@
+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 += "  "
+        string += "\n"
+        
+    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..5f8d2af
--- /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
+    
+    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..533c294
--- /dev/null
+++ b/mathgenerator/funcs/profitLossPercentFunc.py
@@ -0,0 +1,14 @@
+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
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/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
diff --git a/mathgenerator/mathgen.py b/mathgenerator/mathgen.py
index f0d022d..0e813a6 100644
--- a/mathgenerator/mathgen.py
+++ b/mathgenerator/mathgen.py
@@ -1,6 +1,7 @@
 import random
 import math
 import fractions
+from .funcs import *
 
 genList = []
 
@@ -26,1043 +27,10 @@ def genById(id):
     generator = genList[id][2]
     return(generator())
 
-
+#
 def getGenList():
     return(genList)
 
-# || Generator Functions
-
-
-def additionFunc(maxSum=99, maxAddend=50):
-    a = random.randint(0, maxAddend)
-    # The highest value of b will be no higher than the maxsum minus the first number and no higher than the maxAddend as well
-    b = random.randint(0, min((maxSum - a), maxAddend))
-    c = a + b
-    problem = str(a) + "+" + str(b) + "="
-    solution = str(c)
-    return problem, solution
-
-
-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
-
-
-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
-
-
-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
-
-
-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
-
-
-def moduloFunc(maxRes=99, maxModulo=99):
-    a = random.randint(0, maxModulo)
-    b = random.randint(0, min(maxRes, maxModulo))
-    c = a % b
-    problem = str(a) + "%" + str(b) + "="
-    solution = str(c)
-    return problem, solution
-
-
-def squareRootFunc(minNo=1, maxNo=12):
-    b = random.randint(minNo, maxNo)
-    a = b * b
-    problem = "sqrt(" + str(a) + ")="
-    solution = str(b)
-    return problem, solution
-
-
-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
-
-
-def squareFunc(maxSquareNum=20):
-    a = random.randint(1, maxSquareNum)
-    b = a * a
-    problem = str(a) + "^2" + "="
-    solution = str(b)
-    return problem, solution
-
-
-def gcdFunc(maxVal=20):
-    a = random.randint(1, maxVal)
-    b = random.randint(1, maxVal)
-    x, y = a, b
-    while(y):
-        x, y = y, x % y
-    problem = f"GCD of {a} and {b} = "
-    solution = str(x)
-    return problem, solution
-
-
-def lcmFunc(maxVal=20):
-    a = random.randint(1, maxVal)
-    b = random.randint(1, maxVal)
-    x, y = a, b
-    c = 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
-
-
-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
-
-
-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
-
-
-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
-
-
-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
-
-
-def BinaryToDecimalFunc(max_dig=10):
-    problem = ''
-    for i in range(random.randint(1, max_dig)):
-        temp = str(random.randint(0, 1))
-        problem += temp
-
-    solution = int(problem, 2)
-    return problem, solution
-
-
-def divideFractionsFunc(maxVal=10):
-    a = random.randint(1, maxVal)
-    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
-
-
-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
-
-
-def areaOfTriangleFunc(maxA=20, maxB=20, maxC=20):
-    a = random.randint(1, maxA)
-    b = random.randint(1, maxB)
-    c = random.randint(1, maxC)
-    s = (a + b + c) / 2
-    area = (s * (s - a) * (s - b) * (s - c)) ** 0.5
-    problem = "Area of triangle with side lengths: " + \
-        str(a) + " " + str(b) + " " + str(c) + " = "
-    solution = area
-    return problem, solution
-
-
-def isTriangleValidFunc(maxSideLength=50):
-    sideA = random.randint(1, maxSideLength)
-    sideB = random.randint(1, maxSideLength)
-    sideC = random.randint(1, maxSideLength)
-    sideSums = [sideA + sideB, sideB + sideC, sideC + sideA]
-    sides = [sideC, sideA, sideB]
-    exists = True & (sides[0] < sideSums[0]) & (
-        sides[1] < sideSums[1]) & (sides[2] < sideSums[2])
-    problem = f"Does triangle with sides {sideA}, {sideB} and {sideC} exist?"
-    if exists:
-        solution = "Yes"
-        return problem, solution
-    solution = "No"
-    return problem, solution
-
-
-def MidPointOfTwoPointFunc(maxValue=20):
-    x1 = random.randint(-20, maxValue)
-    y1 = random.randint(-20, maxValue)
-    x2 = random.randint(-20, maxValue)
-    y2 = random.randint(-20, maxValue)
-    problem = f"({x1},{y1}),({x2},{y2})="
-    solution = f"({(x1+x2)/2},{(y1+y2)/2})"
-    return problem, solution
-
-
-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
-
-
-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
-
-
-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
-
-
-def distanceTwoPointsFunc(maxValXY=20, minValXY=-20):
-    point1X = random.randint(minValXY, maxValXY + 1)
-    point1Y = random.randint(minValXY, maxValXY + 1)
-    point2X = random.randint(minValXY, maxValXY + 1)
-    point2Y = random.randint(minValXY, maxValXY + 1)
-    distanceSq = (point1X - point2X) ** 2 + (point1Y - point2Y) ** 2
-    solution = f"sqrt({distanceSq})"
-    problem = f"Find the distance between ({point1X}, {point1Y}) and ({point2X}, {point2Y})"
-    return problem, solution
-
-def pythagoreanTheoremFunc(maxLength=20):
-    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
-
-
-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
-
-
-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
-
-
-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
-
-
-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
-
-
-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
-
-
-def factorialFunc(maxInput=6):
-    a = random.randint(0, maxInput)
-    n = a
-    problem = str(a) + "! = "
-    b = 1
-    if a == 1:
-        solution = str(b)
-        return problem, solution
-    else:
-        while n > 0:
-            b *= n
-            n = n - 1
-        solution = str(b)
-        return problem, solution
-
-
-def surfaceAreaCube(maxSide=20, unit='m'):
-    a = random.randint(1, maxSide)
-    problem = f"Surface area of cube with side = {a}{unit} is"
-    ans = 6 * a * a
-    solution = f"{ans} {unit}^2"
-    return problem, solution
-
-
-def volumeCube(maxSide=20, unit='m'):
-    a = random.randint(1, maxSide)
-    problem = f"Volume of cube with side = {a}{unit} is"
-    ans = a * a * a
-    solution = f"{ans} {unit}^3"
-    return problem, solution
-
-
-def surfaceAreaCuboid(maxSide=20, unit='m'):
-    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
-
-
-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
-
-
-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
-
-
-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
-
-
-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
-
-
-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
-
-
-def commonFactorsFunc(maxVal=100):
-    a = random.randint(1, maxVal)
-    b = random.randint(1, maxVal)
-    x, y = a, b
-    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
-
-
-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
-
-
-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
-
-
-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]]
-    return str(a) + " X " + str(b) + " = ", str(c)
-
-
-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
-
-
-def simpleInterestFunc(maxPrinciple=10000, maxRate=10, maxTime=10):
-    a = random.randint(1000, maxPrinciple)
-    b = random.randint(1, maxRate)
-    c = random.randint(1, maxTime)
-    d = (a * b * c) / 100
-    problem = "Simple interest for a principle amount of " + str(a) + " dollars, " + str(
-        b) + "% rate of interest and for a time period of " + str(c) + " years is = "
-    solution = round(d, 2)
-    return problem, solution
-
-
-def matrixMultiplicationFunc(maxVal=100):
-    m = random.randint(2, 10)
-    n = random.randint(2, 10)
-    k = random.randint(2, 10)
-    # generate matrices a and b
-    a = []
-    for r in range(m):
-        a.append([])
-        for c in range(n):
-            a[r].append(random.randint(-maxVal, maxVal))
-
-    b = []
-    for r in range(n):
-        b.append([])
-        for c in range(k):
-            b[r].append(random.randint(-maxVal, maxVal))
-
-    res = []
-    a_string = matrixMultiplicationFuncHelper(a)
-    b_string = matrixMultiplicationFuncHelper(b)
-
-    for r in range(m):
-        res.append([])
-        for c in range(k):
-            temp = 0
-            for t in range(n):
-                temp += a[r][t] * b[t][c]
-            res[r].append(temp)
-    # consider using a, b instead of a_string, b_string if the problem doesn't look right
-    problem = f"Multiply \n{a_string}\n and \n\n{b_string}"
-    solution = matrixMultiplicationFuncHelper(res)
-    return problem, solution
-
-
-def matrixMultiplicationFuncHelper(inp):
-    m = len(inp)
-    n = len(inp[0])
-    string = ""
-    for i in range(m):
-        for j in range(n):
-            string += f"{inp[i][j]: 6d}"
-            string += "  "
-        string += "\n"
-    return string
-
-
-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
-
-
-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 = solution + " + c"
-    return problem, solution
-
-def fourthAngleOfQuadriFunc(total=360):
-    def rand_anglesquad():
-        a=180
-        b=0
-        c=0
-        d=0
-        while(c==0 or d==0):
-            a=random.randint(1, total-20)
-            b=random.randint(1, total-a-10)
-            c=random.randint(1, total-a-b)
-            d=total-a-b-c
-        return a, b, c, d
-    a, b, c, d=rand_anglesquad()
-    problem="Fourth angle of a quadrilateral with three angles {}, {}, {} (in degrees)".format(a, b, c)
-    solution=d
-    return problem, solution
-
-def quadraticEquation(maxVal=100):
-    a = random.randint(1, maxVal)
-    c = random.randint(1, maxVal)
-    b = random.randint(round(math.sqrt(4 * a * c)) + 1,
-                       round(math.sqrt(4 * maxVal * maxVal)))
-
-    problem = "Zeros of the Quadratic Equation {}x^2+{}x+{}=0".format(a, b, c)
-
-    D = math.sqrt(b * b - 4 * a * c)
-
-    solution = str([round((-b + D) / (2 * a), 2),
-                    round((-b - D) / (2 * a), 2)])
-    return problem, solution
-
-
-def hcfFunc(maxVal=20):
-    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
-
-
-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
-
-  
-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
-
-
-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
-
-
-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
-
-
-def fibonacciSeriesFunc(minNo=1):
-    n = random.randint(minNo, 20)
-
-    def createFibList(n):
-        fibList = []
-        for i in range(n):
-            if i < 2:
-                fibList.append(i)
-            else:
-                val = fibList[i - 1] + fibList[i - 2]
-                fibList.append(val)
-        return fibList
-    fibList = createFibList(n)
-    problem = "The Fibonacci Series of the first " + str(n) + " numbers is ?"
-    solution = fibList
-    return problem, solution
-
-
-# Handles degrees in quadrant one
-def basicTrigonometryFunc(angles=[0, 30, 45, 60, 90], functions=["sin", "cos", "tan"]):
-    angle = random.choice(angles)
-    function = random.choice(functions)
-
-    problem = f"What is {function}({angle})?"
-    expression = 'math.' + function + '(math.radians(angle))'
-    result_fraction_map = {0.0: "0", 0.5: "1/2", 0.71: "1/√2",
-                           0.87: "√3/2", 1.0: "1", 0.58: "1/√3", 1.73: "√3"}
-
-    solution = result_fraction_map[round(eval(expression), 2)] if round(
-        eval(expression), 2) <= 99999 else "∞"  # for handling the ∞ condition
-
-    return problem, solution
-
-
-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
-
-
-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
-    problem="Find the mean,standard deviation and variance for the data"+str(random_list)
-    solution="The Mean is {} , Standard Deviation is {}, Variance is {}".format(mean,var/number_values,(var/number_values)**0.5)
-    return problem,solution
-
-
-def surfaceAreaSphere(maxSide=20, unit='m'):
-    r = random.randint(1, maxSide)
-    problem = f"Surface area of Sphere with radius = {r}{unit} is"
-    ans = 4 * math.pi * r * r
-    solution = f"{ans} {unit}^2"
-    return problem, solution
-
-def volumeSphereFunc(maxRadius = 100):
-    r=random.randint(1,maxRadius)
-    problem=f"Volume of sphere with radius {r} m = "
-    ans=(4*math.pi/3)*r*r*r
-    solution = f"{ans} m^3"
-    return problem,solution  
-          
-
-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
-
-def nthFibonacciNumber(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
-
-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
-
-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
-    
-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
-  
-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
-  
-
-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
-  
-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
-
-# || Class Instances
-
-
 # Format is:
 # <title> = Generator("<Title>", <id>, <generalized problem>, <generalized solution>, <function name>)
 addition = Generator("Addition", 0, "a+b=", "c", additionFunc)
@@ -1181,11 +149,10 @@ surfaceAreaSphereGen = Generator(
     "Surface Area of Sphere", 59, "Surface area of sphere with radius = a units is", "d units^2", surfaceAreaSphere)
 volumeSphere = Generator("Volume of Sphere", 60,
                          "Volume of sphere with radius r m = ", "(4*pi/3)*r*r*r", volumeSphereFunc)
-nthFibonacciNumberGen = Generator("nth Fibonacci number", 61, "What is the nth Fibonacci number", "Fn", nthFibonacciNumber)
-
+nthFibonacciNumberGen = Generator("nth Fibonacci number", 61, "What is the nth Fibonacci number", "Fn", nthFibonacciNumberFunc)
 profitLossPercent = Generator("Profit or Loss Percent", 62, "Profit/ Loss percent when CP = cp and SP = sp is: ", "percent", profitLossPercentFunc)
-binaryToHex = Generator("Binary to Hexidecimal", 63, "Hexidecimal of a=", "b", BinaryToHexFunc)
-ComplexNumMultiply = Generator("Multiplication of 2 complex numbers", 64, "(x + j) (y + j) = ", "xy + xj + yj -1", multiplyComplexNumbersFunc)
-geometricprogression=Generator("Geometric Progression", 65, "Initial value,Common Ratio,nth Term,Sum till nth term =", "a,r,ar^n-1,sum(ar^n-1", GeomProgrFunc)
+binaryToHex = Generator("Binary to Hexidecimal", 63, "Hexidecimal of a=", "b", binaryToHexFunc)
+complexNumMultiply = Generator("Multiplication of 2 complex numbers", 64, "(x + j) (y + j) = ", "xy + xj + yj -1", multiplyComplexNumbersFunc)
+geometricprogression=Generator("Geometric Progression", 65, "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",66,"Geometric mean of n numbers A1 , A2 , ... , An = ","(A1*A2*...An)^(1/n) = ans",geometricMeanFunc)
 harmonicMean=Generator("Harmonic Mean of N Numbers",67,"Harmonic mean of n numbers A1 , A2 , ... , An = "," n/((1/A1) + (1/A2) + ... + (1/An)) = ans",harmonicMeanFunc)
diff --git a/test.py b/test.py
new file mode 100644
index 0000000..288c5b3
--- /dev/null
+++ b/test.py
@@ -0,0 +1 @@
+from mathgenerator import mathgen