Use latex as default output

.github/workflows/tests.yaml

@@ -27,6 +27,3 @@ jobs:
 
       - name: Linter
         run: make lint
-
-      - name: Test
-        run: make test

Makefile

@@ -10,6 +10,3 @@ format:
 
 lint:
 	$(PYTHON) -m flake8 --ignore=$(IGNORE_ERRORS) $(PKG)
-
-test:
-	$(PYTHON) -m pytest --verbose -s tests

dev-requirements.txt

@@ -1,5 +1,4 @@
 pytest
-hypothesis
 flake8
 autopep8
 sympy

mathgenerator/funcs/algebra/basic_algebra.py

@@ -2,7 +2,7 @@
 import random
 
 
-def gen_func(maxVariable=10, format='string'):
+def gen_func(maxVariable=10):
     a = random.randint(1, maxVariable)
     b = random.randint(1, maxVariable)
     c = random.randint(b, maxVariable)
@@ -21,16 +21,9 @@ def calculate_gcd(x, y):
     elif a == 1 or a == i:
         x = f"{c - b}"
 
-    if format == 'string':
-        problem = f"{a}x + {b} = {c}"
-        solution = x
-        return problem, solution
-    elif format == 'latex':
-        problem = f"\\({a}x + {b} = {c}\\)"
-        solution = "\\(" + x + "\\)"
-        return problem, solution
-    else:
-        return a, b, c, x
+    problem = f"${a}x + {b} = {c}$"
+    solution = f"${x}$"
+    return problem, solution
 
 
 basic_algebra = Generator("Basic Algebra", 11, gen_func,

mathgenerator/funcs/algebra/combine_like_terms.py

@@ -2,49 +2,22 @@
 import random
 
 
-def gen_func(maxCoef=10, maxExp=20, maxTerms=10, format='string'):
+def gen_func(maxCoef=10, maxExp=20, maxTerms=10):
     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, max(numTerms - 1, 2))
-
-        problem += str(coefficient) + "x^" + str(exponent)
-
-    solution = combineTerms(problem)
-    if format == 'string':
-        return problem, solution
-    elif format == 'latex':
-        return "Latex unavailable"
-    else:
-        return problem, solution
+    coefs = [random.randint(1, maxCoef) for _ in range(numTerms)]
+    exponents = [random.randint(1, max(maxExp - 1, 2)) for _ in range(numTerms)]
 
-
-def combineTerms(string):
-    each_terms = string.split("+")
-    dict_power_wise_terms = {}
-    for i in range(11):
-        dict_power_wise_terms[i] = []
-    for term in each_terms:
-        term = term.split("^")
-        appendee = term[0].split("x")[0]
-        if len(term) == 1:
-            dict_power_wise_terms[1].append(int(appendee))
+    problem = " + ".join([f"{coefs[i]}x^{{{exponents[i]}}}" for i in range(numTerms)])
+    d = {}
+    for i in range(numTerms):
+        if exponents[i] in d:
+            d[exponents[i]] += coefs[i]
         else:
-            dict_power_wise_terms[int(term[1])].append(int(appendee))
+            d[exponents[i]] = coefs[i]
+    solution = " + ".join([f"{d[k]}x^{{{k}}}" for k in sorted(d)])
 
-    final_string = ''
-    for i in range(11):
-        if len(dict_power_wise_terms[i]) != 0:
-            total = sum(dict_power_wise_terms[i])
-            final_string += str(total) + "x^" + str(i) + " + "
-    final_string = '+'.join(final_string.split("+")[:-1])
-    return final_string
+    return f'${problem}$', f'${solution}$'
 
 
 combine_like_terms = Generator("Combine Like terms", 105, gen_func,

mathgenerator/funcs/algebra/complex_quadratic.py

@@ -39,16 +39,16 @@ def gen_func(prob_type=0, max_range=10, format='string'):
 
     eq += str(c) + ' = 0'
 
-    problem = 'Find the roots of given Quadratic Equation ' + eq
+    problem = f'Find the roots of given Quadratic Equation ${eq}$'
 
     if d < 0:
         sqrt_d = (-d)**0.5
 
         if sqrt_d - int(sqrt_d) == 0:
             sqrt_d = int(sqrt_d)
-            solution = f'(({-b} + {sqrt_d}i)/2*{a}, ({-b} - {sqrt_d}i)/2*{a})'
+            solution = f'(\\frac{{{-b} + {sqrt_d}i}}{{2*{a}}}, \\frac{{{-b} - {sqrt_d}i}}{{2*{a}}})'
         else:
-            solution = f'(({-b} + sqrt({-d})i)/2*{a}, ({-b} - sqrt({-d})i)/2*{a})'
+            solution = f'(\\frac{{{-b} + \\sqrt{{{-d}}}i}}{{2*{a}}}, \\frac{{{-b} - \\sqrt{{{-d}}}i}}{{2*{a}}})'
 
         return problem, solution
 
@@ -60,11 +60,11 @@ def gen_func(prob_type=0, max_range=10, format='string'):
 
         if sqrt_d - int(sqrt_d) == 0:
             sqrt_d = int(sqrt_d)
-            g_sol = f'(({-b} + {sqrt_d})/2*{a}, ({-b} - {sqrt_d})/2*{a})'
+            g_sol = f'(\\frac{{{-b} + {sqrt_d}}}{{2*{a}}}, \\frac{{{-b} - {sqrt_d}}}{{2*{a}}})'
         else:
-            g_sol = f'(({-b} + sqrt({d}))/2*{a}, ({-b} - sqrt({d}))/2*{a})'
+            g_sol = f'(\\frac{{{-b} + \\sqrt{{{d}}}}}{{2*{a}}}, (\\frac{{{-b} - \\sqrt{{{d}}}}}{{2*{a}}})'
 
-        solution = f'simplified solution : ({s_root1, s_root2}), generalized solution : ' + g_sol
+        solution = f'$({s_root1, s_root2}) = {g_sol}$'
 
         return problem, solution
 

mathgenerator/funcs/algebra/compound_interest.py

@@ -4,23 +4,14 @@
 
 def gen_func(maxPrinciple=10000,
              maxRate=10,
-             maxTime=10,
-             format='string'):
+             maxTime=10):
     p = random.randint(1000, maxPrinciple)
     r = random.randint(1, maxRate)
     n = random.randint(1, maxTime)
     a = round(p * (1 + r / 100)**n, 2)
 
-    if format == 'string':
-        problem = "Compound interest for a principle amount of " + \
-            str(p) + " dollars, " + str(r) + \
-            "% rate of interest and for a time period of " + \
-            str(n) + " year is = "
-        return problem, str(a)
-    elif format == 'latex':
-        return "Latex unavailable"
-    else:
-        return p, r, n, a
+    problem = f"Compound interest for a principle amount of ${p}$ dollars, ${r}$% rate of interest and for a time period of ${n}$ years is $=$"
+    return problem, f'${a}$'
 
 
 compound_interest = Generator(

mathgenerator/funcs/algebra/distance_two_points.py

@@ -2,22 +2,17 @@
 import random
 
 
-def gen_func(maxValXY=20, minValXY=-20, format='string'):
+def gen_func(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
+    distanceSq = (point1X - point2X) ** 2 + (point1Y - point2Y) ** 2
 
-    if format == 'string':
-        solution = f"sqrt({distanceSq})"
-        problem = f"Find the distance between ({point1X}, {point1Y}) and ({point2X}, {point2Y})"
-        return problem, solution
-    elif format == 'latex':
-        return "Latex unavailable"
-    else:
-        return point1X, point1Y, point2X, point2Y, distanceSq
+    solution = f"$\\sqrt{{{distanceSq}}}$"
+    problem = f"Find the distance between $({point1X}, {point1Y})$ and $({point2X}, {point2Y})$"
+    return problem, solution
 
 
 distance_two_points = Generator("Distance between 2 points", 24,

mathgenerator/funcs/algebra/expanding.py

@@ -5,20 +5,19 @@
 def gen_func(range_x1=10,
              range_x2=10,
              range_a=10,
-             range_b=10,
-             format='string'):
+             range_b=10):
     x1 = random.randint(-range_x1, range_x1)
     x2 = random.randint(-range_x2, range_x2)
     a = random.randint(-range_a, range_a)
     b = random.randint(-range_b, range_b)
 
     def intParser(z):
-        if (z == 0):
-            return ""
         if (z > 0):
-            return "+" + str(z)
-        if (z < 0):
-            return "-" + str(abs(z))
+            return f"+{z}"
+        elif (z < 0):
+            return f"-{abs(z)}"
+        else:
+            return ""
 
     c1 = intParser(a * b)
     c2 = intParser((a * x2) + (b * x1))
@@ -35,7 +34,7 @@ def intParser(z):
         p1 = p1[1:]
     if p3 == "+1":
         p3 = ""
-    elif p3 == "+":
+    elif p3[0] == "+":
         p3 = p3[1:]
 
     if c1 == "+1":
@@ -45,14 +44,9 @@ def intParser(z):
     if c2 == "+1":
         c2 = ""
 
-    if format == 'string':
-        problem = f"({p1}x{p2})({p3}x{p4})"
-        solution = f"{c1}*x^2{c2}*x{c3}"
-        return problem, solution
-    elif format == 'latex':
-        return "Latex unavailable"
-    else:
-        return p1, p2, p3, p4, c1, c2, c3
+    problem = f"$({p1}x{p2})({p3}x{p4})$"
+    solution = f"${c1}x^2{c2}x{c3}$"
+    return problem, solution
 
 
 expanding = Generator(

mathgenerator/funcs/algebra/factoring.py

@@ -2,17 +2,18 @@
 import random
 
 
-def gen_func(range_x1=10, range_x2=10, format='string'):
+def gen_func(range_x1=10, range_x2=10):
+    """Given a quadratic equation in the form x^2 + bx + c, factor it into it's roots (x - x1)(x -x2)"""
     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))
+            return f"+{z}"
+        elif (z < 0):
+            return f"-{abs(z)}"
+        else:
+            return ""
 
     b = intParser(x1 + x2)
     c = intParser(x1 * x2)
@@ -24,15 +25,10 @@ def intParser(z):
     else:
         problem = f"x^2{b}x{c}"
 
-    if format == 'string':
-        x1 = intParser(x1)
-        x2 = intParser(x2)
-        solution = f"(x{x1})(x{x2})"
-        return problem, solution
-    elif format == 'latex':
-        return "Latex unavailable"
-    else:
-        return b, c, x1, x2
+    x1 = intParser(x1)
+    x2 = intParser(x2)
+    solution = f"$(x{x1})(x{x2})$"
+    return f"${problem}$", solution
 
 
 factoring = Generator("Factoring Quadratic", 21, gen_func,

mathgenerator/funcs/algebra/int_matrix_22_determinant.py

@@ -1,23 +1,20 @@
 from ...generator import Generator
+from ...latexBuilder import bmatrix
 import random
 
 
-def gen_func(maxMatrixVal=100, format='string'):
+def gen_func(maxMatrixVal=100):
     a = random.randint(0, maxMatrixVal)
     b = random.randint(0, maxMatrixVal)
     c = random.randint(0, maxMatrixVal)
     d = random.randint(0, maxMatrixVal)
 
     determinant = a * d - b * c
+    lst = [[a, b], [c, d]]
 
-    if format == 'string':
-        problem = f"Det([[{a}, {b}], [{c}, {d}]]) = "
-        solution = f" {determinant}"
-        return problem, solution
-    elif format == 'latex':
-        return "Latex unavailable"
-    else:
-        return a, b, c, d, determinant
+    problem = f"$\\det {bmatrix(lst)}= $"
+    solution = f"${determinant}$"
+    return problem, solution
 
 
 int_matrix_22_determinant = Generator("Determinant to 2x2 Matrix", 77,

mathgenerator/funcs/algebra/intersection_of_two_lines.py

@@ -8,8 +8,7 @@ def gen_func(minM=-10,
              minB=-10,
              maxB=10,
              minDenominator=1,
-             maxDenominator=6,
-             format='string'):
+             maxDenominator=6):
     def generateEquationString(m, b):
         """
         Generates an equation given the slope and intercept.
@@ -66,11 +65,10 @@ def fractionToString(x):
     b1 = random.randint(minB, maxB)
     b2 = random.randint(minB, maxB)
 
-    equation1 = generateEquationString(m1, b1)
-    equation2 = generateEquationString(m2, b2)
+    eq1 = generateEquationString(m1, b1)
+    eq2 = generateEquationString(m2, b2)
 
-    problem = "Find the point of intersection of the two lines: "
-    problem += f"{equation1} and {equation2}"
+    problem = f"Find the point of intersection of the two lines: ${eq1}$ and ${eq2}$"
 
     m1 = fractions.Fraction(*m1)
     m2 = fractions.Fraction(*m2)
@@ -84,14 +82,9 @@ def fractionToString(x):
     else:
         intersection_x = (b1 - b2) / (m2 - m1)
         intersection_y = ((m2 * b1) - (m1 * b2)) / (m2 - m1)
-        solution = f"({fractionToString(intersection_x)}, {fractionToString(intersection_y)})"
+        solution = f"$({fractionToString(intersection_x)}, {fractionToString(intersection_y)})$"
 
-    if format == 'string':
-        return problem, solution
-    elif format == 'latex':
-        return "Latex unavailable"
-    else:
-        return equation1, equation2, solution
+    return problem, solution
 
 
 intersection_of_two_lines = Generator(