mathgenerator.misc

  1import random
  2import math
  3import numpy as np
  4
  5
  6def arithmetic_progression_sum(max_d=100,
  7                               max_a=100,
  8                               max_n=100):
  9    """Arithmetic Progression Sum
 10
 11    | Ex. Problem | Ex. Solution |
 12    | --- | --- |
 13    | Find the sum of first $44$ terms of the AP series: $49, 145, 241 ... $ | $92972.0$ |
 14    """
 15    d = random.randint(-1 * max_d, max_d)
 16    a1 = random.randint(-1 * max_a, max_a)
 17    a2 = a1 + d
 18    a3 = a1 + 2 * d
 19    n = random.randint(4, max_n)
 20    apString = str(a1) + ', ' + str(a2) + ', ' + str(a3) + ' ... '
 21    an = a1 + (n - 1) * d
 22    solution = n * (a1 + an) / 2
 23
 24    problem = f'Find the sum of first ${n}$ terms of the AP series: ${apString}$'
 25    return problem, f'${solution}$'
 26
 27
 28def arithmetic_progression_term(max_d=100,
 29                                max_a=100,
 30                                max_n=100):
 31    """Arithmetic Progression Term
 32
 33    | Ex. Problem | Ex. Solution |
 34    | --- | --- |
 35    | Find term number $12$ of the AP series: $-54, 24, 102 ... $ | $804$ |
 36    """
 37    d = random.randint(-1 * max_d, max_d)
 38    a1 = random.randint(-1 * max_a, max_a)
 39    a2 = a1 + d
 40    a3 = a2 + d
 41    n = random.randint(4, max_n)
 42    apString = str(a1) + ', ' + str(a2) + ', ' + str(a3) + ' ... '
 43    solution = a1 + ((n - 1) * d)
 44
 45    problem = f'Find term number ${n}$ of the AP series: ${apString}$'
 46    return problem, f'${solution}$'
 47
 48
 49def _fromBaseTenTo(n, to_base):
 50    """Converts a decimal number n to another base, to_base.
 51    Utility of base_conversion()
 52    """
 53    alpha = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 54    assert type(
 55        to_base
 56    ) == int and to_base >= 2 and to_base <= 36, "to_base({}) must be >=2 and <=36"
 57    # trivial cases
 58    if to_base == 2:
 59        return bin(n)[2:]
 60    elif to_base == 8:
 61        return oct(n)[2:]
 62    elif to_base == 10:
 63        return str(n)
 64    elif to_base == 16:
 65        return hex(n)[2:].upper()
 66    res = alpha[n % to_base]
 67    n = n // to_base
 68    while n > 0:
 69        res = alpha[n % to_base] + res
 70        n = n // to_base
 71    return res
 72
 73
 74def base_conversion(max_num=60000, max_base=16):
 75    """Base Conversion
 76
 77    | Ex. Problem | Ex. Solution |
 78    | --- | --- |
 79    | Convert $45204$ from base $10$ to base $4$ | $23002110$ |
 80    """
 81    assert type(
 82        max_num
 83    ) == int and max_num >= 100 and max_num <= 65536, "max_num({}) must be >=100 and <=65536".format(
 84        max_num)
 85    assert type(
 86        max_base
 87    ) == int and max_base >= 2 and max_base <= 36, "max_base({}) must be >= 2 and <=36".format(
 88        max_base)
 89
 90    n = random.randint(40, max_num)
 91    dist = [10] * 10 + [2] * 5 + [16] * 5 + [i for i in range(2, max_base + 1)]
 92    # set this way since converting to/from bases 2,10,16 are more common -- can be changed if needed.
 93    bases = random.choices(dist, k=2)
 94    while bases[0] == bases[1]:
 95        bases = random.choices(dist, k=2)
 96
 97    problem = f"Convert ${_fromBaseTenTo(n, bases[0])}$ from base ${bases[0]}$ to base ${bases[1]}$."
 98    ans = _fromBaseTenTo(n, bases[1])
 99    return problem, f'${ans}$'
100
101
102def _newton_symbol(n, k):
103    """Utility of binomial_distribution()"""
104    return math.factorial(n) / (math.factorial(k) * math.factorial(n - k))
105
106
107def binomial_distribution():
108    """Binomial distribution
109
110    | Ex. Problem | Ex. Solution |
111    | --- | --- |
112    | A manufacturer of metal pistons finds that, on average, $30.56$% of the pistons they manufacture are rejected because they are incorrectly sized. What is the probability that a batch of $20$ pistons will contain no more than $2$ rejected pistons? | $3.17$ |
113    """
114    rejected_fraction = float(random.randint(30, 40)) + random.random()
115    batch = random.randint(10, 20)
116    rejections = random.randint(1, 9)
117
118    answer = 0
119    rejected_fraction = round(rejected_fraction, 2)
120    for i in range(0, rejections + 1):
121        answer += _newton_symbol(float(batch), float(i)) * ((rejected_fraction / 100.) ** float(i)) * \
122            ((1 - (rejected_fraction / 100.)) ** (float(batch) - float(i)))
123
124    answer = round(100 * answer, 2)
125
126    problem = "A manufacturer of metal pistons finds that, on average, ${0:}$% "\
127        "of the pistons they manufacture are rejected because " \
128        "they are incorrectly sized. What is the probability that a "\
129        "batch of ${1:}$ pistons will contain no more than ${2:}$ " \
130        "rejected pistons?".format(rejected_fraction, batch, rejections)
131    return problem, f'${answer}$'
132
133
134def celsius_to_fahrenheit(max_temp=100):
135    """Celsius to Fahrenheit
136
137    | Ex. Problem | Ex. Solution |
138    | --- | --- |
139    | Convert $-46$ degrees Celsius to degrees Fahrenheit | $-50.8$ |
140    """
141    celsius = random.randint(-50, max_temp)
142    fahrenheit = (celsius * (9 / 5)) + 32
143
144    problem = f"Convert ${celsius}$ degrees Celsius to degrees Fahrenheit"
145    solution = f'${fahrenheit}$'
146    return problem, solution
147
148
149def common_factors(max_val=100):
150    """Common Factors
151
152    | Ex. Problem | Ex. Solution |
153    | --- | --- |
154    | Common Factors of $100$ and $44 = $ | $[1, 2, 4]$ |
155    """
156    a = x = random.randint(1, max_val)
157    b = y = random.randint(1, max_val)
158
159    if (x < y):
160        min = x
161    else:
162        min = y
163
164    count = 0
165    arr = []
166
167    for i in range(1, min + 1):
168        if (x % i == 0):
169            if (y % i == 0):
170                count = count + 1
171                arr.append(i)
172
173    problem = f"Common Factors of ${a}$ and ${b} = $"
174    solution = f'${arr}$'
175    return problem, solution
176
177
178def complex_to_polar(min_real_imaginary_num=-20,
179                     max_real_imaginary_num=20):
180    r"""Complex to polar form
181
182    | Ex. Problem | Ex. Solution |
183    | --- | --- |
184    | $19.42(-19.0\theta + i-4.0\theta)$ | $-2.93$ |
185    """
186    num = complex(random.randint(min_real_imaginary_num, max_real_imaginary_num),
187                  random.randint(min_real_imaginary_num, max_real_imaginary_num))
188    a = num.real
189    b = num.imag
190    r = round(math.hypot(a, b), 2)
191    theta = round(math.atan2(b, a), 2)
192
193    problem = rf'${r}({a}\theta + i{b}\theta)$'
194    return problem, f'${theta}$'
195
196
197def decimal_to_roman_numerals(max_decimal=4000):
198    """Decimal to Roman Numerals
199
200    | Ex. Problem | Ex. Solution |
201    | --- | --- |
202    | The number $92$ in roman numerals is:  | $XCII$ |
203    """
204    x = random.randint(0, max_decimal)
205    x_copy = x
206    roman_dict = {
207        1: "I",
208        5: "V",
209        10: "X",
210        50: "L",
211        100: "C",
212        500: "D",
213        1000: "M"
214    }
215    div = 1
216    while x >= div:
217        div *= 10
218    div /= 10
219    solution = ""
220    while x:
221        last_value = int(x / div)
222        if last_value <= 3:
223            solution += (roman_dict[div] * last_value)
224        elif last_value == 4:
225            solution += (roman_dict[div] + roman_dict[div * 5])
226        elif 5 <= last_value <= 8:
227            solution += (roman_dict[div * 5] + (roman_dict[div] * (last_value - 5)))
228        elif last_value == 9:
229            solution += (roman_dict[div] + roman_dict[div * 10])
230        x = math.floor(x % div)
231        div /= 10
232
233    problem = f"The number ${x_copy}$ in roman numerals is: "
234    return problem, f'${solution}$'
235
236
237def euclidian_norm(maxEltAmt=20):
238    """Euclidian norm or L2 norm of a vector
239
240    | Ex. Problem | Ex. Solution |
241    | --- | --- |
242    | Euclidian norm or L2 norm of the vector $[659.9225071540442, 243.40887829281564, 128.79950053874424, 263.19226900031344]$ is: | $761.97$ |
243    """
244    vec = [
245        random.uniform(0, 1000) for i in range(random.randint(2, maxEltAmt))
246    ]
247    solution = round(math.sqrt(sum([i**2 for i in vec])), 2)
248
249    problem = f"Euclidian norm or L2 norm of the vector ${vec}$ is:"
250    return problem, f'${solution}$'
251
252
253def factors(max_val=1000):
254    """Factors of a number
255
256    | Ex. Problem | Ex. Solution |
257    | --- | --- |
258    | Factors of $176 = $ | $[1, 2, 4, 8, 11, 16, 22, 44, 88, 176]$ |
259    """
260    n = random.randint(1, max_val)
261
262    factors = []
263
264    for i in range(1, int(n**0.5) + 1):
265        if i**2 == n:
266            factors.append(i)
267        elif n % i == 0:
268            factors.append(i)
269            factors.append(n // i)
270        else:
271            pass
272
273    factors.sort()
274
275    problem = f"Factors of ${n} = $"
276    solution = factors
277    return problem, f'${solution}$'
278
279
280def geometric_mean(max_value=100, max_count=4):
281    """Geometric Mean of N Numbers
282
283    | Ex. Problem | Ex. Solution |
284    | --- | --- |
285    | Geometric mean of $3$ numbers $[72, 21, 87] = $ | $50.86$ |
286    """
287    count = random.randint(2, max_count)
288    nums = [random.randint(1, max_value) for i in range(count)]
289    product = np.prod(nums)
290
291    ans = round(product ** (1 / count), 2)
292    problem = f"Geometric mean of ${count}$ numbers ${nums} = $"
293    # solution = rf"$({'*'.join(map(str, nums))}^{{\frac{{1}}{{{count}}}}} = {ans}$"
294    solution = f"${ans}$"
295    return problem, solution
296
297
298def geometric_progression(number_values=6,
299                          min_value=2,
300                          max_value=12,
301                          n_term=7,
302                          sum_term=5):
303    """Geometric Progression
304
305    | Ex. Problem | Ex. Solution |
306    | --- | --- |
307    | For the given GP $[11, 44, 176, 704, 2816, 11264]$. Find the value of a common ratio, 7th term value, sum upto 10th term | The value of a is $11$, common ratio is $4$ , 7th term is $45056$, sum upto 10th term is $3844775.0$ |
308    """
309    r = random.randint(min_value, max_value)
310    a = random.randint(min_value, max_value)
311    n_term = random.randint(number_values, number_values + 5)
312    sum_term = random.randint(number_values, number_values + 5)
313    GP = []
314    for i in range(number_values):
315        GP.append(a * (r**i))
316    value_nth_term = a * (r**(n_term - 1))
317    sum_till_nth_term = a * ((r**sum_term - 1) / (r - 1))
318
319    problem = f"For the given GP ${GP}$. Find the value of a common ratio, {n_term}th term value, sum upto {sum_term}th term"
320    solution = "The value of a is ${}$, common ratio is ${}$ , {}th term is ${}$, sum upto {}th term is ${}$".format(
321        a, r, n_term, value_nth_term, sum_term, sum_till_nth_term)
322    return problem, solution
323
324
325def harmonic_mean(max_value=100, max_count=4):
326    """Harmonic Mean of N Numbers
327
328    | Ex. Problem | Ex. Solution |
329    | --- | --- |
330    | Harmonic mean of $4$ numbers $52, 56, 25, 57 = $ | $602.33$ |
331    """
332    count = random.randint(2, max_count)
333    nums = [random.randint(1, max_value) for _ in range(count)]
334    sum = 0
335    for num in nums:
336        sum += (1 / num)
337    ans = round(num / sum, 2)
338
339    problem = f"Harmonic mean of ${count}$ numbers ${', '.join(map(str, nums))} = $"
340    solution = f"${ans}$"
341    return problem, solution
342
343
344def is_leap_year(minNumber=1900, max_number=2099):
345    """Is Leap Year or Not
346
347    | Ex. Problem | Ex. Solution |
348    | --- | --- |
349    | Is $2000$ a leap year? | $2000$ is a leap year |
350    """
351    year = random.randint(minNumber, max_number)
352    problem = f"Is {year} a leap year?"
353    if (year % 4) == 0:
354        if (year % 100) == 0:
355            if (year % 400) == 0:
356                ans = True
357            else:
358                ans = False
359        else:
360            ans = True
361    else:
362        ans = False
363
364    solution = f"{year} is{' not' if not ans else ''} a leap year"
365    return problem, solution
366
367
368def lcm(max_val=20):
369    """LCM (Least Common Multiple)
370
371    | Ex. Problem | Ex. Solution |
372    | --- | --- |
373    | LCM of $3$ and $18 = $ | $18$ |
374    """
375    a = random.randint(1, max_val)
376    b = random.randint(1, max_val)
377    c = a * b
378    x, y = a, b
379
380    while y:
381        x, y = y, x % y
382    d = c // x
383
384    problem = f"LCM of ${a}$ and ${b} =$"
385    solution = f'${d}$'
386    return problem, solution
387
388
389def minutes_to_hours(max_minutes=999):
390    """Convert minutes to hours and minutes
391
392    | Ex. Problem | Ex. Solution |
393    | --- | --- |
394    | Convert $836$ minutes to hours & minutes | $13$ hours and $56$ minutes |
395    """
396    minutes = random.randint(1, max_minutes)
397    ansHours = minutes // 60
398    ansMinutes = minutes % 60
399
400    problem = f"Convert ${minutes}$ minutes to hours & minutes"
401    solution = f"${ansHours}$ hours and ${ansMinutes}$ minutes"
402    return problem, solution
403
404
405def prime_factors(min_val=1, max_val=200):
406    """Prime Factors
407
408    | Ex. Problem | Ex. Solution |
409    | --- | --- |
410    | Find prime factors of $30$ | $2, 3, 5$ |
411    """
412    a = random.randint(min_val, max_val)
413    n = a
414    i = 2
415    factors = []
416
417    while i * i <= n:
418        if n % i:
419            i += 1
420        else:
421            n //= i
422            factors.append(i)
423
424    if n > 1:
425        factors.append(n)
426
427    problem = f"Find prime factors of ${a}$"
428    solution = f"${', '.join(map(str, factors))}$"
429    return problem, solution
430
431
432def product_of_scientific_notations(min_exp_val=-100, max_exp_val=100):
433    r"""Product of scientific notations
434
435    | Ex. Problem | Ex. Solution |
436    | --- | --- |
437    | Product of scientific notations $5.11 \times 10^{67}$ and $3.64 \times 10^{-59} = $ | $1.86 \times 10^{9}$ |
438    """
439    a = [round(random.uniform(1, 10), 2),
440         random.randint(min_exp_val, max_exp_val)]
441    b = [round(random.uniform(1, 10), 2),
442         random.randint(min_exp_val, max_exp_val)]
443    c = [a[0] * b[0], a[1] + b[1]]
444
445    if c[0] >= 10:
446        c[0] /= 10
447        c[1] += 1
448
449    problem = rf"Product of scientific notations ${a[0]} \times 10^{{{a[1]}}}$ and ${b[0]} \times 10^{{{b[1]}}} = $"
450    solution = rf'${round(c[0], 2)} \times 10^{{{c[1]}}}$'
451    return problem, solution
452
453
454def profit_loss_percent(max_cp=1000, max_sp=1000):
455    """Profit or Loss Percent
456
457    | Ex. Problem | Ex. Solution |
458    | --- | --- |
459    | Loss percent when $CP = 751$ and $SP = 290$ is: | $61.38$ |
460    """
461    cP = random.randint(1, max_cp)
462    sP = random.randint(1, max_sp)
463    diff = abs(sP - cP)
464    if (sP - cP >= 0):
465        profitOrLoss = "Profit"
466    else:
467        profitOrLoss = "Loss"
468    percent = round(diff / cP * 100, 2)
469
470    problem = f"{profitOrLoss} percent when $CP = {cP}$ and $SP = {sP}$ is: "
471    return problem, f'${percent}$'
472
473
474def quotient_of_power_same_base(max_base=50, max_power=10):
475    """Quotient of Powers with Same Base
476
477    | Ex. Problem | Ex. Solution |
478    | --- | --- |
479    | The Quotient of $5^{6}$ and $5^{8} = 5^{6-8} = 5^{-2}$ | $0.04$ |
480    """
481    base = random.randint(1, max_base)
482    power1 = random.randint(1, max_power)
483    power2 = random.randint(1, max_power)
484    step = power1 - power2
485    solution = base ** step
486
487    problem = f"The Quotient of ${base}^{{{power1}}}$ and ${base}^{{{power2}}} = " \
488        f"{base}^{{{power1}-{power2}}} = {base}^{{{step}}}$"
489    return problem, f'${solution}$'
490
491
492def quotient_of_power_same_power(max_base=50, max_power=10):
493    """Quotient of Powers with Same Power
494
495    | Ex. Problem | Ex. Solution |
496    | --- | --- |
497    | The quotient of $19^{8}$ and $10^{8} = (19/10)^8 = 1.9^{8}$ | $169.84$ |
498    """
499    base1 = random.randint(1, max_base)
500    base2 = random.randint(1, max_base)
501    power = random.randint(1, max_power)
502    step = base1 / base2
503    solution = round(step ** power, 2)
504
505    problem = f"The quotient of ${base1}^{{{power}}}$ and ${base2}^{{{power}}} = " \
506        f"({base1}/{base2})^{power} = {step}^{{{power}}}$"
507    return problem, f'${solution}$'
508
509
510def set_operation(min_size=3, max_size=7):
511    """Union, Intersection, Difference of Two Sets
512
513    | Ex. Problem | Ex. Solution |
514    | --- | --- |
515    | Given the two sets $a={1, 2, 4, 5}$, $b={8, 1, 2}$. Find the Union, intersection, $a-b$, $b-a$, and symmetric difference | Union is ${1, 2, 4, 5, 8}$. Intersection is ${1, 2}$, $a-b$ is ${4, 5}$, $b-a$ is ${8}$. Symmetric difference is ${4, 5, 8}$. |
516    """
517    number_variables_a = random.randint(min_size, max_size)
518    number_variables_b = random.randint(min_size, max_size)
519    a = []
520    b = []
521    for _ in range(number_variables_a):
522        a.append(random.randint(1, 10))
523    for _ in range(number_variables_b):
524        b.append(random.randint(1, 10))
525    a = set(a)
526    b = set(b)
527
528    problem = f"Given the two sets $a={a}$, $b={b}$. " + \
529        "Find the Union, intersection, $a-b$, $b-a$, and symmetric difference"
530    solution = f"Union is ${a.union(b)}$. Intersection is ${a.intersection(b)}$" + \
531        f", $a-b$ is ${a.difference(b)}$, $b-a$ is ${b.difference(a)}$." + \
532        f" Symmetric difference is ${a.symmetric_difference(b)}$."
533    return problem, solution
534
535
536def signum_function(min=-999, max=999):
537    """Signum Function
538
539    | Ex. Problem | Ex. Solution |
540    | --- | --- |
541    | Signum of $-229$ is = | $-1$ |
542    """
543    a = random.randint(min, max)
544    b = 0
545    if (a > 0):
546        b = 1
547    if (a < 0):
548        b = -1
549
550    problem = f"Signum of ${a}$ is ="
551    solution = f'${b}$'
552    return problem, solution
553
554
555def surds_comparison(max_value=100, max_root=10):
556    r"""Comparing Surds
557
558    | Ex. Problem | Ex. Solution |
559    | --- | --- |
560    | Fill in the blanks $42^{\frac{1}{2}}$ _ $45^{\frac{1}{5}}$ | $>$ |
561    """
562    radicand1, radicand2 = tuple(random.sample(range(1, max_value), 2))
563    degree1, degree2 = tuple(random.sample(range(1, max_root), 2))
564    first = math.pow(radicand1, 1 / degree1)
565    second = math.pow(radicand2, 1 / degree2)
566
567    solution = "="
568    if first > second:
569        solution = ">"
570    elif first < second:
571        solution = "<"
572
573    problem = rf"Fill in the blanks ${radicand1}^{{\frac{{1}}{{{degree1}}}}}$ _ ${radicand2}^{{\frac{{1}}{{{degree2}}}}}$"
574    return problem, f'${solution}$'