mathgenerator.algebra

  1from ._latexBuilder import bmatrix
  2import random
  3import math
  4import fractions
  5import sympy
  6
  7
  8def basic_algebra(max_variable=10):
  9    r"""Basic Algebra
 10
 11    | Ex. Problem | Ex. Solution |
 12    | --- | --- |
 13    | $1x + 5 = 5$ | $0$ |
 14    """
 15    a = random.randint(1, max_variable)
 16    b = random.randint(1, max_variable)
 17    c = random.randint(b, max_variable)
 18
 19    # calculate gcd
 20    def calculate_gcd(x, y):
 21        while (y):
 22            x, y = y, x % y
 23        return x
 24
 25    i = calculate_gcd((c - b), a)
 26    x = f"{(c - b)//i}/{a//i}"
 27
 28    if (c - b == 0):
 29        x = "0"
 30    elif a == 1 or a == i:
 31        x = f"{c - b}"
 32
 33    problem = f"${a}x + {b} = {c}$"
 34    solution = f"${x}$"
 35    return problem, solution
 36
 37
 38def combine_like_terms(max_coef=10, max_exp=20, max_terms=10):
 39    r"""Combine Like Terms
 40
 41    | Ex. Problem | Ex. Solution |
 42    | --- | --- |
 43    | $6x^{9} + 3x^{2} + 5x^{19} + 3x^{17}$ | $3x^{2} + 6x^{9} + 3x^{17} + 5x^{19}$ |
 44    """
 45    numTerms = random.randint(1, max_terms)
 46
 47    coefs = [random.randint(1, max_coef) for _ in range(numTerms)]
 48    exponents = [random.randint(1, max(max_exp - 1, 2))
 49                 for _ in range(numTerms)]
 50
 51    problem = " + ".join([f"{coefs[i]}x^{{{exponents[i]}}}" for i in range(numTerms)])
 52    d = {}
 53    for i in range(numTerms):
 54        if exponents[i] in d:
 55            d[exponents[i]] += coefs[i]
 56        else:
 57            d[exponents[i]] = coefs[i]
 58    solution = " + ".join([f"{d[k]}x^{{{k}}}" for k in sorted(d)])
 59
 60    return f'${problem}$', f'${solution}$'
 61
 62
 63def complex_quadratic(prob_type=0, max_range=10):
 64    r"""Complex Quadratic Equation
 65
 66    | Ex. Problem | Ex. Solution |
 67    | --- | --- |
 68    | Find the roots of given Quadratic Equation $x^2 + 8x + 8 = 0$ | $((-1.172, -6.828)) = (\frac{-8 + \sqrt{32}}{2}, (\frac{-8 - \sqrt{32}}{2})$ |
 69    """
 70    if prob_type < 0 or prob_type > 1:
 71        print("prob_type not supported")
 72        print("prob_type = 0 for real roots problems ")
 73        print("prob_tpye = 1 for imaginary roots problems")
 74        return None
 75    if prob_type == 0:
 76        d = -1
 77        while d < 0:
 78            a = random.randrange(1, max_range)
 79            b = random.randrange(1, max_range)
 80            c = random.randrange(1, max_range)
 81
 82            d = (b**2 - 4 * a * c)
 83    else:
 84        d = 0
 85        while d >= 0:
 86            a = random.randrange(1, max_range)
 87            b = random.randrange(1, max_range)
 88            c = random.randrange(1, max_range)
 89
 90            d = (b**2 - 4 * a * c)
 91
 92    eq = ''
 93
 94    if a == 1:
 95        eq += 'x^2 + '
 96    else:
 97        eq += str(a) + 'x^2 + '
 98
 99    if b == 1:
100        eq += 'x + '
101    else:
102        eq += str(b) + 'x + '
103
104    eq += str(c) + ' = 0'
105
106    problem = f'Find the roots of given Quadratic Equation ${eq}$'
107
108    if d < 0:
109        sqrt_d = (-d)**0.5
110
111        if sqrt_d - int(sqrt_d) == 0:
112            sqrt_d = int(sqrt_d)
113            solution = rf'(\frac{{{-b} + {sqrt_d}i}}{{{2*a}}}, \frac{{{-b} - {sqrt_d}i}}{{{2*a}}})'
114        else:
115            solution = rf'(\frac{{{-b} + \sqrt{{{-d}}}i}}{{{2*a}}}, \frac{{{-b} - \sqrt{{{-d}}}i}}{{{2*a}}})'
116
117        return problem, solution
118
119    else:
120        s_root1 = round((-b + (d)**0.5) / (2 * a), 3)
121        s_root2 = round((-b - (d)**0.5) / (2 * a), 3)
122
123        sqrt_d = (d)**0.5
124
125        if sqrt_d - int(sqrt_d) == 0:
126            sqrt_d = int(sqrt_d)
127            g_sol = rf'(\frac{{{-b} + {sqrt_d}}}{{{2*a}}}, \frac{{{-b} - {sqrt_d}}}{{{2*a}}})'
128        else:
129            g_sol = rf'(\frac{{{-b} + \sqrt{{{d}}}}}{{{2*a}}}, (\frac{{{-b} - \sqrt{{{d}}}}}{{{2*a}}})'
130
131        solution = f'$({s_root1, s_root2}) = {g_sol}$'
132
133        return problem, solution
134
135
136def compound_interest(max_principle=10000,
137                      max_rate=10,
138                      max_time=10):
139    r"""Compound Interest
140
141    | Ex. Problem | Ex. Solution |
142    | --- | --- |
143    | Compound interest for a principle amount of $2679$ dollars, $9$% rate of interest and for a time period of $3$ years is $=$ | $3469.38$ |
144    """
145    p = random.randint(1000, max_principle)
146    r = random.randint(1, max_rate)
147    n = random.randint(1, max_time)
148    a = round(p * (1 + r / 100)**n, 2)
149
150    problem = f"Compound interest for a principle amount of ${p}$ dollars, ${r}$% rate of interest and for a time period of ${n}$ years is $=$"
151    return problem, f'${a}$'
152
153
154def distance_two_points(max_val_xy=20, min_val_xy=-20):
155    r"""Distance between 2 points
156
157    | Ex. Problem | Ex. Solution |
158    | --- | --- |
159    | Find the distance between $(-19, -6)$ and $(15, -16)$ | $\sqrt{1256}$ |
160    """
161    point1X = random.randint(min_val_xy, max_val_xy + 1)
162    point1Y = random.randint(min_val_xy, max_val_xy + 1)
163    point2X = random.randint(min_val_xy, max_val_xy + 1)
164    point2Y = random.randint(min_val_xy, max_val_xy + 1)
165
166    distanceSq = (point1X - point2X) ** 2 + (point1Y - point2Y) ** 2
167
168    solution = rf"$\sqrt{{{distanceSq}}}$"
169    problem = f"Find the distance between $({point1X}, {point1Y})$ and $({point2X}, {point2Y})$"
170    return problem, solution
171
172
173def expanding(range_x1=10,
174              range_x2=10,
175              range_a=10,
176              range_b=10):
177    r"""Expanding Factored Binomial
178
179    | Ex. Problem | Ex. Solution |
180    | --- | --- |
181    |$(x-6)(-3x-3)$ | $x^2+18x+18$ |
182    """
183    x1 = random.randint(-range_x1, range_x1)
184    x2 = random.randint(-range_x2, range_x2)
185    a = random.randint(-range_a, range_a)
186    b = random.randint(-range_b, range_b)
187
188    def intParser(z):
189        if (z > 0):
190            return f"+{z}"
191        elif (z < 0):
192            return f"-{abs(z)}"
193        else:
194            return ""
195
196    c1 = intParser(a * b)
197    c2 = intParser((a * x2) + (b * x1))
198    c3 = intParser(x1 * x2)
199
200    p1 = intParser(a)
201    p2 = intParser(x1)
202    p3 = intParser(b)
203    p4 = intParser(x2)
204
205    if p1 == "+1":
206        p1 = ""
207    elif len(p1) > 0 and p1[0] == "+":
208        p1 = p1[1:]
209    if p3 == "+1":
210        p3 = ""
211    elif p3[0] == "+":
212        p3 = p3[1:]
213
214    if c1 == "+1":
215        c1 = ""
216    elif len(c1) > 0 and c1[0] == "+":
217        c1 = c1[1:]  # Cuts off the plus for readability
218    if c2 == "+1":
219        c2 = ""
220
221    problem = f"$({p1}x{p2})({p3}x{p4})$"
222    solution = f"${c1}x^2{c2}x{c3}$"
223    return problem, solution
224
225
226def factoring(range_x1=10, range_x2=10):
227    r"""Factoring Quadratic
228    Given a quadratic equation in the form x^2 + bx + c, factor it into it's roots (x - x1)(x -x2)
229
230    | Ex. Problem | Ex. Solution |
231    | --- | --- |
232    | $x^2+2x-24$ | $(x-4)(x+6)$ |
233    """
234    x1 = random.randint(-range_x1, range_x1)
235    x2 = random.randint(-range_x2, range_x2)
236
237    def intParser(z):
238        if (z > 0):
239            return f"+{z}"
240        elif (z < 0):
241            return f"-{abs(z)}"
242        else:
243            return ""
244
245    b = intParser(x1 + x2)
246    c = intParser(x1 * x2)
247
248    if b == "+1":
249        b = "+"
250    if b == "":
251        problem = f"x^2{c}"
252    else:
253        problem = f"x^2{b}x{c}"
254
255    x1 = intParser(x1)
256    x2 = intParser(x2)
257    solution = f"$(x{x1})(x{x2})$"
258    return f"${problem}$", solution
259
260
261def int_matrix_22_determinant(max_matrix_val=100):
262    r"""Determinant to 2x2 Matrix
263
264    | Ex. Problem | Ex. Solution |
265    | --- | --- |
266    | $\det \begin{bmatrix} 88 & 40 \\\ 9 & 91 \end{bmatrix}= $ | $7648$ |
267    """
268    a = random.randint(0, max_matrix_val)
269    b = random.randint(0, max_matrix_val)
270    c = random.randint(0, max_matrix_val)
271    d = random.randint(0, max_matrix_val)
272
273    determinant = a * d - b * c
274    lst = [[a, b], [c, d]]
275
276    problem = rf"$\det {bmatrix(lst)}= $"
277    solution = f"${determinant}$"
278    return problem, solution
279
280
281def intersection_of_two_lines(min_m=-10,
282                              max_m=10,
283                              min_b=-10,
284                              max_b=10,
285                              min_denominator=1,
286                              max_denominator=6):
287    r"""Intersection of two lines
288
289    | Ex. Problem | Ex. Solution |
290    | --- | --- |
291    | Find the point of intersection of the two lines: $y = \frac{-2}{6}x + 3$ and $y = \frac{3}{6}x - 8$ | $(\frac{66}{5}, \frac{-7}{5})$ |
292    """
293    def generateEquationString(m, b):
294        """
295        Generates an equation given the slope and intercept.
296        It handles cases where m is fractional.
297        It also ensures that we don't have weird signs such as y = mx + -b.
298        """
299        if m[0] == 0:
300            m = 0
301        elif abs(m[0]) == abs(m[1]):
302            m = m[0] // m[1]
303        elif m[1] == 1:
304            m = m[0]
305        else:
306            m = rf"\frac{{{m[0]}}}{{{m[1]}}}"
307        base = "y ="
308        if m != 0:
309            if m == 1:
310                base = f"{base} x"
311            elif m == -1:
312                base = f"{base} -x"
313            else:
314                base = f"{base} {m}x"
315        if b > 0:
316            if m == 0:
317                return f"{base} {b}"
318            else:
319                return f"{base} + {b}"
320        elif b < 0:
321            if m == 0:
322                return f"{base} -{b * -1}"
323            else:
324                return f"{base} - {b * -1}"
325        else:
326            if m == 0:
327                return f"{base} 0"
328            else:
329                return base
330
331    def fractionToString(x):
332        """
333        Converts the given fractions.Fraction into a string.
334        """
335        if x.denominator == 1:
336            x = x.numerator
337        else:
338            x = rf"\frac{{{x.numerator}}}{{{x.denominator}}}"
339        return x
340
341    m1 = (random.randint(min_m,
342                         max_m), random.randint(min_denominator, max_denominator))
343    m2 = (random.randint(min_m,
344                         max_m), random.randint(min_denominator, max_denominator))
345
346    b1 = random.randint(min_b, max_b)
347    b2 = random.randint(min_b, max_b)
348
349    eq1 = generateEquationString(m1, b1)
350    eq2 = generateEquationString(m2, b2)
351
352    problem = f"Find the point of intersection of the two lines: ${eq1}$ and ${eq2}$"
353
354    m1 = fractions.Fraction(*m1)
355    m2 = fractions.Fraction(*m2)
356    # if m1 == m2 then the slopes are equal
357    # This can happen if both line are the same
358    # Or if they are parallel
359    # In either case there is no intersection
360
361    if m1 == m2:
362        solution = "No Solution"
363    else:
364        intersection_x = (b1 - b2) / (m2 - m1)
365        intersection_y = ((m2 * b1) - (m1 * b2)) / (m2 - m1)
366        solution = f"$({fractionToString(intersection_x)}, {fractionToString(intersection_y)})$"
367
368    return problem, solution
369
370
371def invert_matrix(square_matrix_dimension=3,
372                  max_matrix_element=99,
373                  only_integer_elements_in_inverted_matrixe=True):
374    r"""Invert Matrix
375
376    | Ex. Problem | Ex. Solution |
377    | --- | --- |
378    | Inverse of Matrix $\begin{bmatrix} 4 & 1 & 4 \\\ 5 & 1 & 5 \\\ 12 & 3 & 13 \end{bmatrix}$ is: | $\begin{bmatrix} 2 & 1 & -1 \\\ 5 & -4 & 0 \\\ -3 & 0 & 1 \end{bmatrix}$ |
379    """
380    if only_integer_elements_in_inverted_matrixe is True:
381        isItOk = False
382        Mat = list()
383        while (isItOk is False):
384            Mat = list()
385            for i in range(0, square_matrix_dimension):
386                z = list()
387                for j in range(0, square_matrix_dimension):
388                    z.append(0)
389                z[i] = 1
390                Mat.append(z)
391            MaxAllowedMatrixElement = math.ceil(
392                pow(max_matrix_element, 1 / (square_matrix_dimension)))
393            randomlist = random.sample(range(0, MaxAllowedMatrixElement + 1),
394                                       square_matrix_dimension)
395
396            for i in range(0, square_matrix_dimension):
397                if i == square_matrix_dimension - 1:
398                    Mat[0] = [
399                        j + (k * randomlist[i])
400                        for j, k in zip(Mat[0], Mat[i])
401                    ]
402                else:
403                    Mat[i + 1] = [
404                        j + (k * randomlist[i])
405                        for j, k in zip(Mat[i + 1], Mat[i])
406                    ]
407
408            for i in range(1, square_matrix_dimension - 1):
409                Mat[i] = [
410                    sum(i) for i in zip(Mat[square_matrix_dimension - 1], Mat[i])
411                ]
412
413            isItOk = True
414            for i in Mat:
415                for j in i:
416                    if j > max_matrix_element:
417                        isItOk = False
418                        break
419                if isItOk is False:
420                    break
421
422        random.shuffle(Mat)
423        Mat = sympy.Matrix(Mat)
424        Mat = sympy.Matrix.transpose(Mat)
425        Mat = Mat.tolist()
426        random.shuffle(Mat)
427        Mat = sympy.Matrix(Mat)
428        Mat = sympy.Matrix.transpose(Mat)
429
430    else:
431        randomlist = list(sympy.primerange(0, max_matrix_element + 1))
432        plist = random.sample(randomlist, square_matrix_dimension)
433        randomlist = random.sample(
434            range(0, max_matrix_element + 1),
435            square_matrix_dimension * square_matrix_dimension)
436        randomlist = list(set(randomlist) - set(plist))
437        n_list = random.sample(
438            randomlist, square_matrix_dimension * (square_matrix_dimension - 1))
439        Mat = list()
440        for i in range(0, square_matrix_dimension):
441            z = list()
442            z.append(plist[i])
443            for j in range(0, square_matrix_dimension - 1):
444                z.append(n_list[(i * square_matrix_dimension) + j - i])
445            random.shuffle(z)
446            Mat.append(z)
447        Mat = sympy.Matrix(Mat)
448
449    problem = 'Inverse of Matrix $' + bmatrix(Mat.tolist()) + '$ is:'
450    solution = f'${bmatrix(sympy.Matrix.inv(Mat).tolist())}$'
451    return problem, solution
452
453
454def linear_equations(n=2, var_range=20, coeff_range=20):
455    r"""Linear Equations
456
457    | Ex. Problem | Ex. Solution |
458    | --- | --- |
459    | Given the equations $10x + -20y = 310$ and $-16x + -17y = 141$, solve for $x$ and $y$ | $x = 5$, $y = -13$ |
460    """
461    if n > 10:
462        print("[!] n cannot be greater than 10")
463        return None, None
464
465    vars = ['x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g'][:n]
466    soln = [random.randint(-var_range, var_range) for i in range(n)]
467    problem = list()
468    solution = "$, $".join(
469        ["{} = {}".format(vars[i], soln[i]) for i in range(n)])
470
471    for _ in range(n):
472        coeff = [random.randint(-coeff_range, coeff_range) for i in range(n)]
473        res = sum([coeff[i] * soln[i] for i in range(n)])
474        prob = [
475            "{}{}".format(coeff[i], vars[i]) if coeff[i] != 0 else ""
476            for i in range(n)
477        ]
478
479        while "" in prob:
480            prob.remove("")
481        prob = " + ".join(prob) + " = " + str(res)
482        problem.append(prob)
483
484    # problem = "\n".join(problem)
485    problem = "$ and $".join(problem)
486
487    return f'Given the equations ${problem}$, solve for $x$ and $y$', f'${solution}$'
488
489
490def line_equation_from_2_points(max_val=20):
491    r"""Equation of Line from Two Points
492
493    | Ex. Problem | Ex. Solution |
494    | --- | --- |
495    | Find the equation of the line passing through the points $(-19,-8)$ and $(-2,0)$. | $y=\frac{8}{17}x+\frac{16}{17}$ |
496    """
497    x1 = random.randint(-max_val, max_val)
498    x2 = random.randint(-max_val, max_val)
499    if x1 == x2:
500        return line_equation_from_2_points(max_val=max_val)
501    y1 = random.randint(-max_val, max_val)
502    y2 = random.randint(-max_val, max_val)
503    m1 = (y2 - y1) // math.gcd(y2 - y1, x2 - x1)
504    m2 = (x2 - x1) // math.gcd(y2 - y1, x2 - x1)
505    c1 = (y1 * (x2 - x1) - (y2 - y1) * x1) // math.gcd(y1 * (x2 - x1) - (y2 - y1) * x1, (x2 - x1))
506    c2 = (x2 - x1) // math.gcd(y1 * (x2 - x1) - (y2 - y1) * x1, (x2 - x1))
507    c = rf"{'+' if c1 >= 0 else '-'}\frac{{{abs(c1)}}}{{{c2}}}" if c1 != 0 else ""
508    if c2 < 0:
509        c2 = -c2
510        c1 = -c1
511        c = rf"{'+' if c1 >= 0 else '-'}\frac{{{abs(c1)}}}{{{c2}}}"
512    if c2 == 1:
513        c = f"{c1:+}"
514
515    problem = f'Find the equation of the line passing through the points $({x1},{y1})$ and $({x2},{y2})$.'
516
517    if m1 == 0:
518        return problem, f"$y={c}$"
519    if m2 < 0:
520        m1 = -m1
521        m2 = -m2
522    if m2 == 1:
523        if m1 == 1:
524            return problem, f"$y=x{c}$"
525        if m1 == -1:
526            return problem, f"$y=-x{c}$"
527        return problem, f"y={m1}x{c}"
528
529    return problem, rf"$y=\frac{{{m1}}}{{{m2}}}x{c}$"
530
531
532def log(max_base=3, max_val=8):
533    r"""Logarithm
534
535    | Ex. Problem | Ex. Solution |
536    | --- | --- |
537    | $log_{3}(243)=$ | $5$ |
538    """
539    a = random.randint(1, max_val)
540    b = random.randint(2, max_base)
541    c = pow(b, a)
542
543    problem = f'$log_{{{b}}}({c})=$'
544    solution = f'${a}$'
545    return problem, solution
546
547
548def matrix_multiplication(max_val=100, max_dim=10):
549    r"""Multiply Two Matrices
550
551    | Ex. Problem | Ex. Solution |
552    | --- | --- |
553    | Multiply $\begin{bmatrix} 15 & 72 \\\ 64 & -20 \\\ 18 & 59 \\\ -21 & -55 \\\ 20 & -12 \\\ -75 & -42 \\\ 47 & 89 \\\ -53 & 27 \\\ -56 & 44 \end{bmatrix}$ and $\begin{bmatrix} 49 & -2 & 68 & -28 \\\ 49 & 6 & 83 & 42 \end{bmatrix}$ | $\begin{bmatrix} 4263 & 402 & 6996 & 2604 \\\ 2156 & -248 & 2692 & -2632 \\\ 3773 & 318 & 6121 & 1974 \\\ -3724 & -288 & -5993 & -1722 \\\ 392 & -112 & 364 & -1064 \\\ -5733 & -102 & -8586 & 336 \\\ 6664 & 440 & 10583 & 2422 \\\ -1274 & 268 & -1363 & 2618 \\\ -588 & 376 & -156 & 3416 \end{bmatrix}$ |
554    """
555    m = random.randint(2, max_dim)
556    n = random.randint(2, max_dim)
557    k = random.randint(2, max_dim)
558
559    # generate matrices a and b
560    a = [[random.randint(-max_val, max_val) for _ in range(n)]
561         for _ in range(m)]
562    b = [[random.randint(-max_val, max_val) for _ in range(k)]
563         for _ in range(n)]
564
565    res = []
566    for r in range(m):
567        res.append([])
568        for c in range(k):
569            temp = 0
570            for t in range(n):
571                temp += a[r][t] * b[t][c]
572            res[r].append(temp)
573
574    problem = f"Multiply ${bmatrix(a)}$ and ${bmatrix(b)}$"
575    solution = f'${bmatrix(res)}$'
576    return problem, solution
577
578
579def midpoint_of_two_points(max_value=20):
580    r"""Midpoint of two points
581
582    | Ex. Problem | Ex. Solution |
583    | --- | --- |
584    | The midpoint of $(-8,10)$ and $(18,0) = $ | $(5.0,5.0)$ |
585    """
586    x1 = random.randint(-20, max_value)
587    y1 = random.randint(-20, max_value)
588    x2 = random.randint(-20, max_value)
589    y2 = random.randint(-20, max_value)
590    xm = (x1 + x2) / 2
591    ym = (y1 + y2) / 2
592
593    problem = f"The midpoint of $({x1},{y1})$ and $({x2},{y2}) = $"
594    solution = f"$({xm},{ym})$"
595    return problem, solution
596
597
598def multiply_complex_numbers(min_real_imaginary_num=-20,
599                             max_real_imaginary_num=20):
600    r"""Multiplication of 2 complex numbers
601
602    | Ex. Problem | Ex. Solution |
603    | --- | --- |
604    | $(14+18j) * (14+15j) = $ | $(-74+462j)$ |
605    """
606    num1 = complex(random.randint(min_real_imaginary_num, max_real_imaginary_num),
607                   random.randint(min_real_imaginary_num, max_real_imaginary_num))
608    num2 = complex(random.randint(min_real_imaginary_num, max_real_imaginary_num),
609                   random.randint(min_real_imaginary_num, max_real_imaginary_num))
610    product = num1 * num2
611
612    problem = f"${num1} * {num2} = $"
613    solution = f'${product}$'
614    return problem, solution
615
616
617def multiply_int_to_22_matrix(max_matrix_val=10, max_res=100):
618    r"""Multiply Integer to 2x2 Matrix
619
620    | Ex. Problem | Ex. Solution |
621    | --- | --- |
622    | $5 * \begin{bmatrix} 1 & 0 \\\ 2 & 9 \end{bmatrix} =$ | $\begin{bmatrix} 5 & 0 \\\ 10 & 45 \end{bmatrix}$ |
623    """
624    a = random.randint(0, max_matrix_val)
625    b = random.randint(0, max_matrix_val)
626    c = random.randint(0, max_matrix_val)
627    d = random.randint(0, max_matrix_val)
628
629    constant = random.randint(0, int(max_res / max(a, b, c, d)))
630
631    a1 = a * constant
632    b1 = b * constant
633    c1 = c * constant
634    d1 = d * constant
635    lst = [[a, b], [c, d]]
636    lst1 = [[a1, b1], [c1, d1]]
637
638    problem = f'${constant} * {bmatrix(lst)} =$'
639    solution = f'${bmatrix(lst1)}$'
640    return problem, solution
641
642
643def quadratic_equation(max_val=100):
644    r"""Quadratic Equation
645
646    | Ex. Problem | Ex. Solution |
647    | --- | --- |
648    | What are the zeros of the quadratic equation $22x^2+137x+25=0$ | ${-0.19, -6.04}$ |
649    """
650    a = random.randint(1, max_val)
651    c = random.randint(1, max_val)
652    b = random.randint(
653        round(math.sqrt(4 * a * c)) + 1, round(math.sqrt(4 * max_val * max_val)))
654    D = math.sqrt(b * b - 4 * a * c)
655    res = {round((-b + D) / (2 * a), 2), round((-b - D) / (2 * a), 2)}
656
657    problem = f"What are the zeros of the quadratic equation ${a}x^2+{b}x+{c}=0$"
658    solution = f'${res}$'
659    return problem, solution
660
661
662def simple_interest(max_principle=10000,
663                    max_rate=10,
664                    max_time=10):
665    r"""Simple Interest
666
667    | Ex. Problem | Ex. Solution |
668    | --- | --- |
669    | Simple interest for a principle amount of $7217$ dollars, $3$% rate of interest and for a time period of $10$ years is $=$ | $2165.1$ |
670    """
671    p = random.randint(1000, max_principle)
672    r = random.randint(1, max_rate)
673    t = random.randint(1, max_time)
674    s = round((p * r * t) / 100, 2)
675
676    problem = f"Simple interest for a principle amount of ${p}$ dollars, ${r}$% rate of interest and for a time period of ${t}$ years is $=$ "
677    solution = f'${s}$'
678    return problem, solution
679
680
681def system_of_equations(range_x=10,
682                        range_y=10,
683                        coeff_mult_range=10):
684    r"""Solve a System of Equations in R^2
685
686    | Ex. Problem | Ex. Solution |
687    | --- | --- |
688    | Given $-x + 5y = -28$ and $9x + 2y = 64$, solve for $x$ and $y$. | $x = 8$, $y = -4$ |
689    """
690    # Generate solution point first
691    x = random.randint(-range_x, range_x)
692    y = random.randint(-range_y, range_y)
693    # Start from reduced echelon form (coeffs 1)
694    c1 = [1, 0, x]
695    c2 = [0, 1, y]
696
697    def randNonZero():
698        return random.choice(
699            [i for i in range(-coeff_mult_range, coeff_mult_range) if i != 0])
700
701    # Add random (non-zero) multiple of equations (rows) to each other
702    c1_mult = randNonZero()
703    c2_mult = randNonZero()
704    new_c1 = [c1[i] + c1_mult * c2[i] for i in range(len(c1))]
705    new_c2 = [c2[i] + c2_mult * c1[i] for i in range(len(c2))]
706    # For extra randomness, now add random (non-zero) multiples of original rows
707    # to themselves
708    c1_mult = randNonZero()
709    c2_mult = randNonZero()
710    new_c1 = [new_c1[i] + c1_mult * c1[i] for i in range(len(c1))]
711    new_c2 = [new_c2[i] + c2_mult * c2[i] for i in range(len(c2))]
712
713    def coeffToFuncString(coeffs):
714        # lots of edge cases for perfect formatting!
715        x_sign = '-' if coeffs[0] < 0 else ''
716        # No redundant 1s
717        x_coeff = str(abs(coeffs[0])) if abs(coeffs[0]) != 1 else ''
718        # If x coeff is 0, dont include x
719        x_str = f'{x_sign}{x_coeff}x' if coeffs[0] != 0 else ''
720        # if x isn't included and y is positive, dont include operator
721        op = ' - ' if coeffs[1] < 0 else (' + ' if x_str != '' else '')
722        # No redundant 1s
723        y_coeff = abs(coeffs[1]) if abs(coeffs[1]) != 1 else ''
724        # Don't include if 0, unless x is also 0 (probably never happens)
725        y_str = f'{y_coeff}y' if coeffs[1] != 0 else (
726            '' if x_str != '' else '0')
727        return f'{x_str}{op}{y_str} = {coeffs[2]}'
728
729    problem = f"Given ${coeffToFuncString(new_c1)}$ and ${coeffToFuncString(new_c2)}$, solve for $x$ and $y$."
730    solution = f"$x = {x}$, $y = {y}$"
731    return problem, solution
732    # Add random (non-zero) multiple of equations to each other
733
734
735def vector_cross(min_val=-20, max_val=20):
736    r"""Cross product of 2 vectors
737
738    | Ex. Problem | Ex. Solution |
739    | --- | --- |
740    | $[-1, -4, 10] \times [-11, 1, -16] = $ | $[54, -126, -45]$ |
741    """
742    a = [random.randint(min_val, max_val) for _ in range(3)]
743    b = [random.randint(min_val, max_val) for _ in range(3)]
744    c = [
745        a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2],
746        a[0] * b[1] - a[1] * b[0]
747    ]
748
749    problem = rf"${a} \times {b} = $"
750    solution = f"${c}$"
751    return problem, solution
752
753
754def vector_dot(min_val=-20, max_val=20):
755    r"""Dot product of 2 vectors
756
757    | Ex. Problem | Ex. Solution |
758    | --- | --- |
759    | $[12, -9, -8]\cdot[-9, 8, 1]=$ | $-188$ |
760    """
761    a = [random.randint(min_val, max_val) for i in range(3)]
762    b = [random.randint(min_val, max_val) for i in range(3)]
763    c = a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
764
765    problem = rf'${a}\cdot{b}=$'
766    solution = f'${c}$'
767    return problem, solution
768
769
770def orthogonal_projection(min_val=-10, max_val=10):
771    r"""Orthogonal Projection
772
773    | Ex. Problem | Ex. Solution |
774    | --- | --- |
775    | Find the orthogonal projection of $[2, 3]$ onto $[4, -7]$ | $[\frac{-4}{5}, \frac{7}{5}]$ |
776    """
777    v = [random.randint(min_val, max_val) for _ in range(2)]
778    u = [random.randint(min_val, max_val) for _ in range(2)]
779    dot_t = v[0] * u[0] + v[1] * u[1]
780    dot_b = u[0] * u[0] + u[1] * u[1]
781    frac = fractions.Fraction(dot_t, dot_b).limit_denominator()
782    y = [frac * u[0], frac * u[1]]
783
784    if y[0].denominator != 1:
785        y[0] = rf'\frac{{{y[0].numerator}}}{{{y[0].denominator}}}'
786    if y[1].denominator != 1:
787        y[1] = rf'\frac{{{y[1].numerator}}}{{{y[1].denominator}}}'
788
789    problem = f'Find the orthogonal projection of ${v}$ onto ${u}$'
790    solution = f'$[{y[0]}, {y[1]}]$'
791    return problem, solution