def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
b1 = random.randint(1, 5)
b2 = random.randint(1, 5)
while b1/b2 % 1 == 0:
b2 = random.randint(1, 5)
q = random.randint(2, 5)
p = random_non_zero_integer(-7,7)
while p/q % 1 == 0:
p = random_non_zero_integer(-7,7)
numer = b1**q
denom = b2**q
quot = sy.Rational(numer, denom)
expr = f'\\left({sy.latex(quot)}\\right)^{{ {sy.latex(sy.Rational(p,q))} }}'
self.answer = sy.Pow(sy.Rational(b1, b2), p)
# print('self.answer:', self.answer)
self.format_answer = f'\( {sy.latex(self.answer)} \)'
self.format_given = f"""
\\[
{expr}
\\]"""
self.prompt_single = f"""Simplify. In particular, rewrite the term without
the use of any negative exponents."""
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'p' in kwargs:
self.p = kwargs['p']
else:
self.p = random_non_zero_integer(-5, 5)
if 'q' in kwargs:
self.q = kwargs['q']
else:
self.q = random_non_zero_integer(-5, 5)
while abs(self.p / self.q) == 1:
self.p = random.randint(-5, 5)
self.q = random_non_zero_integer(-5, 5)
self.m = Rational(self.p, self.q)
if 'x0' in kwargs:
self.x0 = kwargs['x0']
else:
self.x0 = random_non_zero_integer(-5, 5)
if 'y0' in kwargs:
self.y0 = kwargs['y0']
else:
self.y0 = random.randint(-5, 5)
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
self.genproblem()
self.format_given = """
<blockquote>
The line that passes through the point \\( ({x0}, {y0}) \\)
and has slope of \\( m = {m} \\)
</blockquote>
""".format(x0=latex(self.x0), y0=latex(self.y0), m=latex(self.m))
self.format_answer = f'\( y = {latex(self.answer)}\)'
# self.answer_latex = latex_print(self.answer)
# self.answer_latex_display = latex_print(self.answer, display=True)
self.prompt_single = """Give an equation for the line described as follows."""
self.prompt_multiple = """Give an equation for each of the lines described below."""
self.format_given_for_tex = """{prompt}
\\begin{{center}}
The line that passes through the point \\( ({x0}, {y0}) \\)
and has slope of \\( m = {m} \\)
\\end{{center}}
""".format(prompt=self.prompt_single,
x0=latex(self.x0),
y0=latex(self.y0),
m=latex(self.m))
self.format_fragment_for_tex = """
The line that passes through the point \\( ({x0}, {y0}) \\)
and has slope of \\( m = {m} \\)
""".format(x0=latex(self.x0), y0=latex(self.y0), m=latex(self.m))
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
bases = list(range(2, 10)) + list(sy.symbols('a b c d x y z u v'))
base = random.choice(bases)
b = base
q1 = random.randint(2, 5)
q2 = random.randint(2, 5)
p1 = random_non_zero_integer(-7, 7)
p2 = random_non_zero_integer(-7, 7)
while p1 / q1 % 1 == 0:
p1 = random_non_zero_integer(-7, 7)
q2 = random.choice([q2, q1])
p1, p2 = random.choice([[p1, p2], [p2, p1]])
expr = f'\\frac{{ {base}^{{ {sy.latex(sy.Rational(p1,q1))} }} }}{{ {base}^{{ {sy.latex(sy.Rational(p2,q2))} }} }}'
self.answer = b**sy.Rational(p1, q1) / b**sy.Rational(p2, q2)
# print('self.answer:', self.answer)
self.format_answer = f'\( {sy.latex(b)}^{{ {sy.latex(sy.Rational(p1, q1) - sy.Rational(p2,q2))} }} \)'
self.format_given = f"""
\\[
{expr}
\\]"""
self.prompt_single = f"""Simplify—in the sense of rewriting
as a single exponential term (that is, a term of the form \\(a^b\\)).
You can assume all variables represent positive numbers in case
of ambiguity.
"""
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
p = random.randint(2, 4)
a = random.randint(-7, 7)
root_answer = random.choice([True, True, False])
if root_answer:
if p % 2 == 0:
a = sy.Abs(a)
T = sy.Pow(a, sy.Rational(1, p))
else:
T = a
whether_b = random.choice([True, True, True, False])
whether_A = random.choice([True, True, True, False])
whether_C = random.choice([True, True, True, False])
if whether_b:
b = random_non_zero_integer(-10, 10)
else:
b = 0
if whether_A:
A = random_non_zero_integer(-10, 10)
else:
A = 1
if whether_C:
C = random_non_zero_integer(-10, 10)
else:
C = 0
x = sy.Symbol('x', real=True)
LHS = sy.Add(sy.Mul(A, (x - b)**p, evaluate=False), C, evaluate=False)
RHS = A * (T)**p + C
prob = sy.Eq(LHS, RHS)
self.answer = set(sy.solve(prob, x))
self.has_solutions = self.answer != set()
if self.has_solutions:
format_answer = ''
for ans in self.answer:
format_answer += sy.latex(ans) + ' ,'
format_answer = format_answer[:-2]
self.format_answer = '\(' + format_answer + '\)'
else:
# self.answer = 'No solution'
self.format_answer = self.answer
self.format_given = f"""
\\[
{sy.latex(prob)}
\\]"""
self.prompt_single = f"""Find all reals that solve the equation.
(Find the solution set—the set of all real numbers that would make the equation
true when substituted in.)
"""
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'no_solution' in kwargs:
self.no_solution = kwargs['no_solution']
else:
self.no_solution = random.choice([False, False, False, True])
if 'difficulty' in kwargs:
self.difficulty = kwargs['difficulty']
else:
self.difficulty = random.choice([1, 1, 2, 3])
if 'a' in kwargs:
self.a = kwargs['a']
else:
if self.difficulty == 1:
self.a = 1
elif self.difficulty == 2:
_a = random.choice(['a', 'c'])
if _a == 'a':
self.a = random.randint(2, 9)
else:
self.a = 1
else:
self.a = random.randint(2, 9)
if 'b' in kwargs:
self.b = kwargs['b']
else:
self.b = random_non_zero_integer(-9, 9)
if 'c' in kwargs:
self.c = kwargs['c']
else:
if self.difficulty == 1:
self.c = 0
elif self.difficulty == 2:
if _a == 'a':
self.c = 0
else:
self.c = random_non_zero_integer(-9, 9)
else:
self.c = random_non_zero_integer(-9, 9)
if 'd' in kwargs:
self.d = kwargs['d']
else:
if self.no_solution:
self.d = random.randint(-9, -1)
else:
self.d = random.randint(0, 9)
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
self.genproblem()
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'a' in kwargs:
self.a = kwargs['a']
else:
a = 0
while a == 0:
a = int(random.triangular(-9, 9))
self.a = 1
symb_a = '{}'.format(a)
if a == 1:
symb_a = ''
elif a == -1:
symb_a = '-'
if 'x1' in kwargs:
self.x1 = kwargs['x1']
else:
self.x1 = random_non_zero_integer(-9, 9)
# if 'gcf' in kwargs:
# self.gcf = kwargs['gcf']
# else:
# self.gcf = random.choice([False, False, True])
# if self.gcf:
# self.x2 = 0
# else:
if 'x2' in kwargs:
self.x2 = kwargs['x2']
else:
self.x2 = random_non_zero_integer(-9, 9)
# self.x2 = self.x1
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
a = self.a
x1 = self.x1
x2 = self.x2
x = self.x
self.answer = set([x1, x2])
ans = ''
for answer in self.answer:
ans += latex(answer) + ', '
ans = ans[:-2]
self.format_answer = f'\( {ans}\)'
expr = expand((x - x1) * (x - x2))
self.format_given = f"\\[{latex(expr)} = 0 \\]"
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
b1 = random.randint(-5, 5)
b2 = random.randint(-5, 5)
x = sy.Symbol('x')
c = random_non_zero_integer(-5, 5)
d = b1 + b2 - c
A = c * d - b1 * b2
while A == 0:
c = random_non_zero_integer(-5, 5)
d = b1 + b2 - c
A = c * d - b1 * b2
factors = list_integer_factors(A)
a1 = random.choice(factors)
a2 = int(A / a1)
n1 = a1
n2 = x + c
d1 = x + d
d2 = a2
if abs(a2) != 1:
prob = '\\frac{{{n1}}}{{{d1}}} = \\frac{{{n2}}}{{{d2}}}'.format(
n1=n1, n2=n2, d1=d1, d2=d2)
else:
prob = '\\frac{{{n1}}}{{{d1}}} = {expr}'.format(n1=n1,
d1=d1,
expr=sy.latex(n2 /
d2))
self.answer = set(sy.solve(n1 / d1 - n2 / d2, x))
# print(self.answer)
if self.answer == set():
fmt_ans = 'No solution'
self.has_solutions = False
else:
self.has_solutions = True
fmt_ans = '\\( '
for ans in self.answer:
fmt_ans += f'{sy.latex(ans)}, '
fmt_ans = fmt_ans[:-2]
fmt_ans += ' \\)'
self.format_answer = fmt_ans
self.format_given = f"\\[{prob}\\]"
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'x0' in kwargs:
self.x0 = kwargs['x0']
else:
self.x0 = random_non_zero_integer(-8, 8)
if 'y0' in kwargs:
self.y0 = kwargs['y0']
else:
self.y0 = random.randint(-8, 8)
if 'x1' in kwargs:
self.x1 = kwargs['x1']
else:
self.x1 = random_non_zero_integer(-8, 8)
while self.x1 == self.x0:
self.x1 = random_non_zero_integer(-8, 8)
if 'y1' in kwargs:
self.y1 = kwargs['y1']
else:
self.y1 = random.randint(-8, 8)
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
self.genproblem()
points = [[self.x0, self.y0], [self.x1, self.y1]]
poly_points = self.get_svg_data([-10, 10])
self.format_given = """
\\[
({x0}, {y0}), ({x1}, {y1})
\\]
""".format(x0=self.x0, y0=self.y0, x1=self.x1, y1=self.y1)
self.format_answer = f'\( y = {latex(self.answer)}\)'
# self.answer_latex = latex_print(self.answer)
# self.answer_latex_display = latex_print(self.answer, display=True)
self.prompt_single = """Develop an equation for the line
that passes through the given points.
"""
self.prompt_multiple = """For each of the following,
develop an equation for the line
that passes through the given points."""
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'a' in kwargs:
self.a = kwargs['a']
else:
self.a = random_non_zero_integer(-9,9)
if 'b' in kwargs:
self.b = kwargs['b']
else:
self.b = random_non_zero_integer(-9,9)
if 'r' in kwargs:
self.r = kwargs['r']
else:
r = random_non_zero_integer(-9,9)
while r == 1 or r == -1:
r = random_non_zero_integer(-9,9)
self.r = r
if 'e' in kwargs:
self.e = kwargs['e']
else:
self.e = random.choice([0,1])
# if 'gcf' in kwargs:
# self.gcf = kwargs['gcf']
# else:
# self.gcf = random.choice([False, False, True])
# if self.gcf:
# self.x2 = 0
# else:
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
a = self.a
b = self.b
r = self.r
e = self.e
x = self.x
self.answer = factor(r*x**e*(a*x+b))
self.format_answer = f'\( {latex(self.answer)}\)'
self.format_given = f"\\[{latex(expand(self.answer))} \\]"
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'b' in 'kwargs':
self.b = kwargs['b']
else:
b = random.randint(-255, 255)
self.b = b / 10
if 'm' in 'kwargs':
self.m = kwargs['m']
else:
self.m = random_non_zero_integer(-99, 99) / 10
# print(self.m)
x = Symbol('x')
self.answer = self.m * x + self.b
self.format_answer = f'\(y = {latex(self.answer)}\)'
self.prompt_single = f"""
Develop an equation that captures the relationship between \(x\)
and \(y\).
"""
prompt_multiple = f"""For each of the following tables,
develop an equation that captures the relationship between \(x\)
and \(y\).
"""
self.genproblem()
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'b' in 'kwargs':
self.b = kwargs['b']
else:
b = random.randint(-255, 255)
self.b = b / 10
if 'm' in 'kwargs':
self.m = kwargs['m']
else:
self.m = random_non_zero_integer(-99, 99) / 10
# print(self.m)
x = Symbol('x')
self.formula = self.m * x + self.b
self.input = random.randint(6, 20)
self.answer = self.formula.subs(x, self.input)
self.format_answer = '\({}\)'.format(self.answer)
self.prompt_single = f"""
Compute the value of \(y\) when \(x = {self.input}\)
"""
prompt_multiple = f"""This needs some thinking...
"""
self.genproblem()
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'Q' in kwargs:
self.Q = kwargs['Q']
else:
signs = ['\\leq', '\\geq', '\\lt', '\\gt']
self.Q = random.choice(signs)
if 'a' in kwargs:
self.a = kwargs['a']
else:
self.a = random_non_zero_integer(-9, 9)
if 'b' in kwargs:
self.b = kwargs['b']
else:
self.b = random.randint(-9, 9)
if 'c' in kwargs:
self.c = kwargs['c']
else:
self.c = random_non_zero_integer(-9, 9)
if 'd' in kwargs:
self.d = kwargs['d']
else:
self.d = random.randint(-9, 9)
if 'e' in kwargs:
self.e = kwargs['e']
else:
offset = random_non_zero_integer(-9, 9)
self.e = -(self.a + self.c) + offset
if 'f' in kwargs:
self.f = kwargs['f']
else:
offset = random_non_zero_integer(-9, 9)
self.f = -(self.a * self.b + self.c * self.d) + offset
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
if 'difficulty' in kwargs:
self.difficulty = kwargs['difficulty']
else:
self.difficulty = random.choice([1, 1, 2, 3])
self.genproblem()
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'p' in kwargs:
self.p = kwargs['p']
else:
self.p = random.randint(-5, 5)
# self.p = 0
if 'q' in kwargs:
self.q = kwargs['q']
else:
self.q = random_non_zero_integer(-5, 5)
self.m = Rational(self.p, self.q)
if 'b' in kwargs:
self.b = kwargs['b']
else:
self.b = random.randint(-7, 7)
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
self.genproblem()
self.format_given = """
<blockquote>
The line that has \\(y\\)-intercept of {b}
and has slope of \\( m = {m} \\)
</blockquote>
""".format(b=latex(self.b), m=latex(self.m))
self.format_answer = '\\quad\n'
# self.answer_latex = latex_print(self.answer)
# self.answer_latex_display = latex_print(self.answer, display=True)
self.prompt_single = """Graph the line described by plotting at least
two points."""
self.prompt_multiple = """This needs to be rethought."""
self.format_given_for_tex = f"""
Graph the line described. Make sure your graph is accurate throughout
the window and has at least two points clearly marked.
\\begin{{center}}
The line that has \\(y\\)-intercept of \\({self.b}\\)
and has slope of \\( m = {latex(self.m)} \\)
\\end{{center}}
\\begin{{flushright}}
\\includegraphics[scale=0.6]{{../common_imgs/blank}}
\\end{{flushright}}
\\vspace{{-9\\baselineskip}}
"""
self.format_fragment_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
i = sy.Symbol('i')
a = random_non_zero_integer(-9, 9)
b = random_non_zero_integer(-9, 9)
inner_term = a + b * i
def disp_complex_style(a, b, i):
if b > 0:
if b == 1:
disp_b = '+'
else:
disp_b = '+ ' + sy.latex(b)
else:
if b == -1:
disp_b = '-'
else:
disp_b = sy.latex(b)
return sy.latex(a) + ' ' + disp_b + sy.latex(i)
disp_inner_term = disp_complex_style(a, b, i)
c = random_non_zero_integer(-9, 9)
d = random_non_zero_integer(-9, 9)
outer_term = c + d * i
disp_outer_term = disp_complex_style(c, d, i)
self.prompt_single = f"""
Simplify the following expression by using all the usual rules
of arithmetic together with the added rule that \(i^2 = -1\).
"""
self.format_given = f'\\[\\left({disp_outer_term}\\right)\\left({disp_inner_term}\\right)\\]'
# self.further_instruction = f"""Only give a numerical answer (no letter symbols)."""
expr = outer_term * (inner_term)
self.answer = sy.expand(expr.subs(i, sy.I))
# print(self.answer)
self.format_answer = f'\({sy.latex(self.answer)}\)'
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'a' in kwargs:
self.a = kwargs['a']
else:
self.a = random_non_zero_integer(-8,8)
if 'b' in kwargs:
self.b = kwargs['b']
else:
self.b = random_non_zero_integer(-8,8)
if 'd' in kwargs:
self.d = kwargs['d']
else:
self.d = random_non_zero_integer(-8,8)
self.m = -Rational(self.b, self.a)
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
if 'y' in kwargs:
self.y = kwargs['y']
else:
self.y = Symbol('y')
self.genproblem()
self.lhs = self.b*self.d*self.x + self.a*self.d*self.y
self.rhs = self.a*self.b*self.d
self.given = Eq(self.lhs, self.rhs)
self.format_given = f"\\[ {latex(self.lhs)} = {latex(self.rhs)} \\]"
self.format_answer = '\\quad\n'
# self.answer_latex = latex_print(self.answer)
# self.answer_latex_display = latex_print(self.answer, display=True)
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'a' in kwargs:
self.a = kwargs['p']
else:
a = 0
while a == 0:
a = int(random.triangular(-9, 9))
self.a = a
symb_a = '{}'.format(a)
if a == 1:
symb_a = ''
elif a == -1:
symb_a = '-'
if 'h' in kwargs:
self.h = kwargs['h']
else:
self.h = random_non_zero_integer(-5, 5)
if 'k' in kwargs:
self.k = kwargs['k']
else:
self.k = random_non_zero_integer(-5, 5)
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
a = self.a
h = self.h
k = self.k
x = self.x
self.answer = expand(a * (x - h)**2 + k)
self.format_answer = f'\( {latex(self.answer)}\)'
self.format_given = f"\\[f(x) = {symb_a}\\left({x-h}\\right)^2{sgn(k)}{abs(k)}\\]"
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'a' in kwargs:
self.a = kwargs['a']
else:
self.a = random_non_zero_integer(-5, 5)
if 'b' in kwargs:
self.b = kwargs['b']
else:
self.b = random.randint(-10, 10)
if 'c' in kwargs:
self.c = kwargs['c']
else:
self.c = random.randint(-10, 10)
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
a = self.a
b = self.b
c = self.c
h = Rational(-b, 2 * a)
x = self.x
self.answer = a * x**2 + b * x + c
self.format_answer = f'\\(y = {latex(self.answer)}\\)'
expr = self.answer
x_points = []
for i in range(3):
x_point = random.randint(-5, 5)
while x_point in x_points:
x_point = random.randint(-5, 5)
x_points.append(x_point)
self.points = [(x_point, expr.subs(x, x_point))
for x_point in x_points]
print_points = ''
for point in self.points:
print_points += f'{latex(point)}, '
print_points = print_points[:-2]
self.format_given = f"""
\\[
{print_points}
\\]
"""
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'a' in kwargs:
self.a = kwargs['p']
else:
a = 0
while a == 0:
a = int(random.triangular(-9, 9))
self.a = a
symb_a = '{}'.format(a)
if a == 1:
symb_a = ''
elif a == -1:
symb_a = '-'
if 'x1' in kwargs:
self.x1 = kwargs['x1']
else:
self.x1 = random_non_zero_integer(-9, 9)
if 'x2' in kwargs:
self.x2 = kwargs['x2']
else:
self.x2 = random_non_zero_integer(-9, 9)
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
a = self.a
x1 = self.x1
x2 = self.x2
x = self.x
self.answer = expand(a * (x - x1) * (x - x2))
self.format_answer = f'\( {latex(self.answer)}\)'
self.format_given = f"\\[f(x) = {symb_a}\\left({latex(x-x1)}\\right)\left({latex(x-x2)}\\right)\\]"
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
a1 = random_non_zero_integer(-5, 5)
a2 = random_non_zero_integer(-5, 5)
b1 = random.randint(-5, 5)
b2 = random.randint(-5, 5)
x = sy.Symbol('x')
d1 = x - b1
d2 = x - b2
prob = '\\frac{{{a1}}}{{{d1}}} = \\frac{{{a2}}}{{{d2}}}'.format(a1=a1,
a2=a2,
d1=d1,
d2=d2)
self.answer = set(sy.solve(a1 / d1 - a2 / d2, x))
# print(self.answer)
if self.answer == set():
fmt_ans = 'No solution'
self.has_solutions = False
else:
self.has_solutions = True
fmt_ans = '\\( '
for ans in self.answer:
fmt_ans += f'{sy.latex(ans)}, '
fmt_ans = fmt_ans[:-2]
fmt_ans += ' \\)'
self.format_answer = fmt_ans
self.format_given = f"\\[{prob}\\]"
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'p' in kwargs:
self.p = kwargs['p']
else:
self.p = random.randint(-5, 5)
if 'q' in kwargs:
self.q = kwargs['q']
else:
self.q = random_non_zero_integer(-5, 5)
self.m = Rational(self.p, self.q)
if 'b' in kwargs:
self.b = kwargs['b']
else:
self.b = random.randint(-7, 7)
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
self.genproblem()
# self.given = self.problem['given']
# self.answer = self.problem['answer']
self.given_latex = '\\(y = ' + commute_sum(self.given) + '\\)'
self.format_given = self.given_latex
self.given_latex_display = '\\[y = ' + commute_sum(self.given) + '\\]'
self.format_answer = '\\quad\n'
# self.answer_latex = latex_print(self.answer)
# self.answer_latex_display = latex_print(self.answer, display=True)
self.format_given_for_tex = f"""
def basic_pow_term(**kwargs):
if 'seed' in kwargs:
seed = kwargs['seed']
else:
seed = random.random()
# print('basic pow term seed', seed)
random.seed(seed)
if 'const_range' in kwargs:
a, b = kwargs['const_range']
A = random_non_zero_integer(a, b)
else:
A = random_non_zero_integer(-9, 9)
if 'const_power_range' in kwargs:
a, b = kwargs['const_power_range']
e_const = random.randint(a, b)
else:
e_const = random.randint(-9, 9)
if 'variables' in kwargs:
variables = []
for variable in kwargs['variables']:
variables.append(variable)
else:
n = random.randint(0, 3)
variables = []
if n > 0:
variables.append('x')
if n > 1:
variables.append('y')
if n > 2:
variables.append('z')
e = []
if 'var_power_ranges' in kwargs:
for r in kwargs['var_power_ranges']:
a, b = r
e.append(random.randint(a, b))
else:
for var in variables:
e.append(random.randint(-5, 5))
fmt_out = ''
term = 1
if A < 0:
parens = random.choice([True, False])
if parens and e_const != 1:
# print('parens:', A, e_const)
fmt_out += pow_neg_style('\\left({A}\\right)'.format(A=A),
e_const)
term *= sy.Pow(A, e_const)
# print('term:', term)
else:
fmt_out += pow_neg_style(A, e_const)
term *= -sy.Pow(abs(A), e_const)
elif A != 1:
fmt_out = pow_neg_style(A, e_const)
term *= sy.Pow(A, e_const)
elif A == -1:
fmt_out += '-'
term *= -1
i = 0
for var in variables:
fmt_out += pow_neg_style(var, e[i])
term *= sy.Pow(sy.Symbol(var), e[i])
i += 1
return {'fmt': fmt_out, 'sym': term}
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'p' in kwargs:
self.p = kwargs['p']
else:
self.p = random_non_zero_integer(-7, 7)
# self.p = -1
if 'q' in kwargs:
self.q = kwargs['q']
else:
self.q = random_non_zero_integer(-5, 5)
# self.q = -3
if 'r' in kwargs:
self.r = kwargs['r']
else:
self.r = random.randint(2, 6)
# self.r=5
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
x = self.x
r = self.r
p = self.p
q = self.q
expr = 1
for num in [p, q]:
new_r = r
depth = 1
while new_r / 2 % 1 == 0 and num < 0 and (-num)**(
1 / (depth + 1)) % 1 == 0:
depth += 1
new_r = int(new_r / 2)
expr *= (x**new_r + int((-num)**(1 / depth)))
if new_r < r:
expr *= (x**new_r - int((abs(num))**(1 / depth)))
else:
expr *= (x**r + num)
# if r % 2 == 0:
# if sqrt(-p) % 1 == 0 and p < 0:
# expr *= (x**int(r/2)+sqrt(-p))*(x**int(r/2)-sqrt(-p))
# #print('1st step: So far its ', expr)
# else:
# expr *= (x**r+p)
# if sqrt(-q) % 1 == 0 and q < 0:
# expr *= (x**int(r/2)+sqrt(-q))*(x**int(r/2)-sqrt(-q))
# else:
# expr *= (x**r+q)
# #print('2nd step: So far its ', expr)
# else:
# expr = (x**r+p)*(x**r+q)
# self.given = self.problem['given']
# self.answer = self.problem['answer']
# expr = (x**r + p)*(x**r+q)
self.answer = expr #factor(expr)
self.format_answer = '\\(' + latex(self.answer) + '\\)'
self.format_given = '\\[' + latex(expand(expr)) + '\\]'
# self.given_latex = latex_print(self.given)
# self.given_latex_display = latex_print(self.given, display=True)
# self.answer_latex = latex_print(self.answer)
# self.format_answer = self.answer_latex
# self.answer_latex_display = latex_print(self.answer, display=True)
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
# seq = [{'a': 1}, {'a': 2}, {'a': 3}]
# get_the_bugs_out = sorted(seq, key=lambda d: d['a'])
# get_the_bugs_out = LinearOrAbs(1, 1, 1, Symbol('x'), True) #Does Python make a call to random.random() when loading classes???
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
print('seed:', self.seed)
random.seed(self.seed)
if 'd' in kwargs:
self.d = kwargs['d']
else:
self.d = random.randint(-6, 6)
# self.d = 2
if 'num_abs_val_terms' in kwargs:
self.num_abs_val_terms = kwargs['num_abs_val_terms']
else:
self.num_abs_val_terms = random.choice([1, 2, 3])
# self.num_abs_val_terms = 3
if 'force_infinite_solutions' in kwargs:
self.force_infinite_solutions = kwargs['force_infinite_solutions']
else:
self.force_infinite_solutions = random.choice([False, False, True])
self.force_infinite_solutions = True
if 'guarantee_solution' in kwargs:
self.guarantee_solution = kwargs['guarantee_solution']
else:
self.guarantee_solution = random.choice([False, True])
self.guarantee_solution = True
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
x = self.x
if self.force_infinite_solutions:
a1 = random.randint(1, 9)
s1 = random.choice([-1, 1])
b1 = random.randint(-9, 9)
# print(s1, a1, b1)
if self.num_abs_val_terms == 1:
a2 = a1
s2 = random.choice([-1, 1])
b2 = random.randint(-9, 9)
while b2 == b1:
b2 = random.randint(-9, 9)
abs_val_terms = [LinearOrAbs(s1, a1, b1, self.x, True)]
random.seed(self.seed)
# print(s1, a2, b1, s2, a2, b2)
if s1 * a1 + s2 * a2 == 0:
self.d = -s1 * b1 - s2 * b2
elif -s1 * a1 + s2 * a1 == 0:
self.d = s1 * b1 - s2 * b2
linear_term = s2 * (a2 * self.x + b2) + self.d
elif self.num_abs_val_terms == 2:
linear_x = random.choice([True, False])
linear_x = True
if linear_x:
a2 = random.randint(1, 9)
s2 = random.choice([-1, 1])
b2 = random.randint(-9, 9)
print(s2, a2, b2)
# i = 0
while a1 == a2 and b2 == b1:
# print(i)
# i += 1
b2 = random.randint(-9, 9)
# random.seed(self.seed)
abs_val_terms = [
LinearOrAbs(s1, a1, b1, self.x, True),
LinearOrAbs(s2, a2, b2, self.x, True)
]
random.seed(
self.seed
) #Don't know why this is needed---but seems to be needed at this precise spot: what does Python do on the first run of the class that it doesn't do on subsequent run in same session???
abs_val_terms = sorted(abs_val_terms,
key=lambda term: term.zero)
s1 = abs_val_terms[0].sign
a1 = abs_val_terms[0].a
b1 = abs_val_terms[0].b
s2 = abs_val_terms[1].sign
a2 = abs_val_terms[1].a
b2 = abs_val_terms[1].b
# random.seed(self.seed)
where = random.choice([0, 1, 2])
# print('where:', where)
if where == 0:
a3 = s1 * a1 + s2 * a2
b3 = s1 * b1 + s2 * b2
elif where == 1:
a3 = -s1 * a1 + s2 * a2
b3 = -s1 * b1 + s2 * b2
elif where == 2:
a3 = -s1 * a1 - s2 * a2
b3 = -s1 * b1 - s2 * b2
linear_term = a3 * x + b3
else:
a2 = a1
s2 = random.choice([-1, 1])
b2 = random.randint(-9, 9)
while b2 == b1:
b2 = random.randint(-9, 9)
abs_val_terms = [
LinearOrAbs(s1, a1, b1, self.x, True),
LinearOrAbs(s2, a2, b2, self.x, True)
]
random.seed(self.seed)
abs_val_terms = sorted(abs_val_terms,
key=lambda term: term.zero)
s1 = abs_val_terms[0].sign
a1 = abs_val_terms[0].a
b1 = abs_val_terms[0].b
s2 = abs_val_terms[1].sign
a2 = abs_val_terms[1].a
b2 = abs_val_terms[1].b
if s1 * a1 + s2 * a2 == 0:
self.d = random.choice(
[-s1 * b1 - s2 * b2, s1 * b1 + s2 * b2])
elif s1 * a1 - s2 * a2 == 0:
self.d = s1 * b1 - s2 * b2
linear_term = self.d
elif self.num_abs_val_terms == 3:
a2 = random.randint(1, 9)
s2 = random.choice([-1, 1])
b2 = random.randint(-9, 9)
# print(s2, a2, b2)
# i = 0
while a1 == a2 and b2 == b1:
# print(i)
# i += 1
b2 = random.randint(-9, 9)
# random.seed(self.seed)
abs_val_terms = [
LinearOrAbs(s1, a1, b1, self.x, True),
LinearOrAbs(s2, a2, b2, self.x, True)
]
random.seed(
self.seed
) #Don't know why this is needed---but seems to be needed at this precise spot: what does Python do on the first run of the class that it doesn't do on subsequent run in same session???
abs_val_terms = sorted(abs_val_terms,
key=lambda term: term.zero)
s1 = abs_val_terms[0].sign
a1 = abs_val_terms[0].a
b1 = abs_val_terms[0].b
s2 = abs_val_terms[1].sign
a2 = abs_val_terms[1].a
b2 = abs_val_terms[1].b
# random.seed(self.seed)
where = random.choice([0, 1, 2])
# print('where:', where)
if where == 0:
a3 = s1 * a1 + s2 * a2
b3 = s1 * b1 + s2 * b2
if a3 < 0:
a3, b3 = -a3, -b3
elif where == 1:
a3 = -s1 * a1 + s2 * a2
b3 = -s1 * b1 + s2 * b2
if a3 < 0:
a3, b3 = -a3, -b3
elif where == 2:
a3 = -s1 * a1 - s2 * a2
b3 = -s1 * b1 - s2 * b2
if a3 < 0:
a3, b3 = -a3, -b3
last = LinearOrAbs(random.choice([-1, 1]), a3, b3, self.x,
True)
random.seed(self.seed)
abs_val_terms.append(last)
linear_term = 0
else:
coeffs = []
signs = []
for i in range(self.num_abs_val_terms):
# random.seed(self.seed)
sign = random.choice([-1, 1])
signs.append(sign)
a = random.randint(1, 4)
b = int(random.triangular(-9, 9, 0))
# print('a, b:', a, b)
while [a, b] in coeffs:
# print('a, b, coeffs:', a, b, coeffs)
a = random.randint(1, 4)
b = int(random.triangular(-9, 9, 0))
coeffs.append([a, b])
abs_val_terms = []
for i in range(self.num_abs_val_terms):
sign = signs[i]
a, b = coeffs[i]
abs_val_terms.append(LinearOrAbs(sign, a, b, self.x, True))
random.seed(self.seed)
# abs_val_terms = [LinearOrAbs(1, 1, 2, self.x, True), LinearOrAbs(-1, 1, 0, self.x, True)]
# random.seed(self.seed)
if self.num_abs_val_terms == 1:
linear_term = random_non_zero_integer(-5, 5) * self.x + self.d
else:
linear_term = random.choice([1, 0]) * random.randint(
-5, 5) * self.x + self.d
# linear_term = 2
if self.guarantee_solution and not self.force_infinite_solutions:
# random.seed(self.seed)
sol = random.randint(-10, 10)
# print('sol', sol)
terms = [term.term for term in abs_val_terms]
terms.append(linear_term)
expr = sum(terms)
add_in = -expr.subs(self.x, sol)
linear_term += add_in
self.linear_term = linear_term
solution_set = EmptySet
abs_val_terms = sorted(abs_val_terms, key=lambda term: term.zero)
self.abs_val_terms = [term.term for term in abs_val_terms]
# print('terms', [term.term for term in abs_val_terms])
i = 0
r = -oo
while i < len(abs_val_terms):
zero = abs_val_terms[i].zero
l, r = r, zero
# print(i, 'interval:', l, r)
# print(i, 'zero:', zero)
expr = 0
for term in abs_val_terms:
# print('term:', term.term)
if zero <= term.zero:
addin = -term.sign * term.kern
# print('addin', addin)
# print('kern', term.kern)
# print('a', term.a)
# print('sign', term.sign)
else:
addin = term.sign * term.kern
expr += addin
expr += linear_term
# print('expr', i, ':', expr)
if simplify(expr) == 0:
solution_set = solution_set.union(Interval(l, r))
elif simplify(expr).is_number:
# print('was number')
pass
else:
sol = solve(expr)[0]
# print('sol', sol)
if sol in Interval(l, r):
print(i, True)
solution_set = solution_set.union(FiniteSet(sol))
i += 1
l, r = r, oo
expr = 0
# print(i, 'interval:', l, r)
# print(i, 'zero:', zero)
for term in abs_val_terms:
addin = term.sign * term.kern
expr += addin
expr += linear_term
# print('expr', 'last:', expr)
if simplify(expr) == 0:
solution_set = solution_set.union(Interval(l, r))
else:
if solve(expr) != []:
sol = solve(expr)[0]
# print('sol', sol)
if sol in Interval(l, r):
solution_set = solution_set.union(FiniteSet(sol))
self.solution_set = solution_set
self.format_answer = f'\\({latex(self.solution_set)}\\)'
print(self.format_answer)
terms = [term.term for term in abs_val_terms]
terms.append(linear_term)
eq = permute_equation(terms, True, seed=self.seed)
self.given = eq
self.format_given = f'\\[{latex(eq[0])} = {latex(eq[1])}\\]'
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'how_many' in kwargs:
self.how_many = kwargs['how_many']
else:
self.how_many = random.choice([0, 1, 1, 1, 1, oo])
self.x_soln = random.randint(-10, 10)
self.y_soln = random.randint(-10, 10)
self.a = random_non_zero_integer(-10, 10)
self.b = random_non_zero_integer(-10, 10)
c = random_non_zero_integer(-10, 10)
d = random_non_zero_integer(-10, 10)
if self.how_many == 1:
while self.a * d - self.b * c == 0:
d = random_non_zero_integer(-10, 10)
self.c = c
self.d = d
self.e0 = self.a * self.x_soln + self.b * self.y_soln
self.e1 = self.c * self.x_soln + self.d * self.y_soln
else:
factor = random.choice([-5, -4, -3, -2, -1, 2, 3, 4, 5])
self.c = factor * self.a
self.d = factor * self.b
self.e0 = self.a * self.x_soln + self.b * self.y_soln
e1 = random.randint(-10, 10)
if self.how_many == 0:
while e1 == factor * self.e0:
e1 = random.randint(-10, 10)
else:
e1 = factor * self.e0
self.e1 = e1
x, y = symbols('x y')
self.eq1 = Eq(self.a * x + self.b * y, self.e0)
self.eq2 = Eq(self.c * x + self.d * y, self.e1)
self.format_given = f"""
\\[
\\begin{{cases}}
{latex(self.eq1)}\\\\
{latex(self.eq2)}
\\end{{cases}}
\\]
"""
if self.how_many == 0:
self.format_answer = 'No solution'
elif self.how_many == 1:
self.format_answer = f'\(x = {self.x_soln}, y = {self.y_soln}\)'
else:
self.answer = solve(self.eq1, y)[0]
self.format_answer = f'\({latex(self.eq1)}\)'
# self.answer_latex = latex_print(self.answer)
# self.answer_latex_display = latex_print(self.answer, display=True)
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'x0' in kwargs:
self.x0 = kwargs['x0']
else:
self.x0 = random_non_zero_integer(-8,8)
if 'y0' in kwargs:
self.y0 = kwargs['y0']
else:
self.y0 = random.randint(-8, 8)
if 'orientation' in kwargs:
self.orientation = kwargs['orientation']
else:
self.orientation = random.choice(['vert', 'horiz'])
if 'parallel_or_perp' in kwargs:
self.parallel_or_perp = kwargs['parallel_or_perp']
else:
self.parallel_or_perp = random.choice(['parallel', 'perpendicular'])
if self.orientation == 'vert':
self.symb = Symbol('x')
self.value = self.x0
if self.parallel_or_perp == 'parallel':
ax_name = '\(y\)'
alt_symb = 'x'
else:
ax_name = '\(x\)'
alt_symb = 'y'
else: #horiz
self.symb = Symbol('y')
self.value = self.y0
if self.parallel_or_perp == 'parallel':
ax_name = '\(x\)'
alt_symb = 'y'
else:
ax_name = '\(y\)'
alt_symb = 'x'
alt_value = random.randint(-9,9)
alt_line_choices = [
f'the {ax_name}-axis',
f'the line with equation \({alt_symb} = {alt_value}\)'
]
self.given_line = random.choice(alt_line_choices)
self.lhs = self.symb
self.rhs = self.value
# self.given = Eq(self.lhs, self.rhs)
self.answer = self.value
self.format_given = f"""
<div style="text-align:center">
The line is {self.parallel_or_perp} to {self.given_line}
and passes through \(({self.x0}, {self.y0})\).
</div>
"""
self.format_answer = f'\({self.symb} = {self.value}\)'
# self.answer_latex = latex_print(self.answer)
# self.answer_latex_display = latex_print(self.answer, display=True)
self.format_given_for_tex = f"""
Develop an equation for the line described here.
\\begin{{center}}
The line is {self.parallel_or_perp} to {self.given_line}
and passes through \(({self.x0}, {self.y0})\).
\\end{{center}}
"""
self.format_fragment_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'how_many' in kwargs:
self.how_many = kwargs['how_many']
else:
self.how_many = random.choice([0, 1, 1, 1, 1, oo])
# self.how_many = 1
self.x_soln = random.randint(-10, 10)
self.y_soln = random.randint(-10, 10)
a = random_non_zero_integer(-10, 10)
b = random_non_zero_integer(-10, 10)
c = random_non_zero_integer(-10, 10)
d = random_non_zero_integer(-10, 10)
factor = random.choice([-5, -4, -3, -2, -1, 2, 3, 4, 5])
solve_for_which = random.choice(['x', 'y'])
top = random.choice([True, False])
if self.how_many == 1:
if solve_for_which == 'x':
if top:
a = random.choice([-1, 1])
else:
c = random.choice([-1, 1])
while a * d - b * c == 0:
d = random_non_zero_integer(-10, 10)
if solve_for_which == 'y':
if top:
b = random.choice([-1, 1])
else:
d = random.choice([-1, 1])
while a * d - b * c == 0:
c = random_non_zero_integer(-10, 10)
e0 = a * self.x_soln + b * self.y_soln
e1 = c * self.x_soln + d * self.y_soln
if self.how_many == 0:
e0 = random.randint(-10, 10)
e1 = random.randint(-10, 10)
if solve_for_which == 'x':
if top:
a = random.choice([-1, 1])
c = a * factor
d = b * factor
while e1 == e0 * factor:
e1 = random.randint(-10, 10)
else:
c = random.choice([-1, 1])
a = c * factor
b = d * factor
while e0 == e1 * factor:
e0 = random.randint(-10, 10)
if solve_for_which == 'y':
if top:
b = random.choice([-1, 1])
d = b * factor
c = a * factor
while e1 == e0 * factor:
e1 = random.randint(-10, 10)
else:
d = random.choice([-1, 1])
b = d * factor
a = c * factor
while e0 == e1 * factor:
e0 = random.randint(-10, 10)
if self.how_many == oo:
e0 = random.randint(-10, 10)
e1 = random.randint(-10, 10)
if solve_for_which == 'x':
if top:
a = random.choice([-1, 1])
c = a * factor
d = b * factor
e1 = e0 * factor
else:
c = random.choice([-1, 1])
a = c * factor
b = d * factor
e0 = e1 * factor
if solve_for_which == 'y':
if top:
b = random.choice([-1, 1])
d = b * factor
c = a * factor
e1 = e0 * factor
else:
d = random.choice([-1, 1])
b = d * factor
a = c * factor
e0 = e1 * factor
x, y = symbols('x y')
self.a = a
self.b = b
self.c = c
self.d = d
self.e0 = e0
self.e1 = e1
self.eq1 = Eq(self.a * x + self.b * y, self.e0)
self.eq2 = Eq(self.c * x + self.d * y, self.e1)
self.format_given = f"""
\\[
\\begin{{cases}}
{latex(self.eq1)}\\\\
{latex(self.eq2)}
\\end{{cases}}
\\]
"""
if self.how_many == 0:
self.format_answer = 'No solution'
elif self.how_many == 1:
self.format_answer = f'\(x = {self.x_soln}, y = {self.y_soln}\)'
else:
self.answer = solve(self.eq1, y)[0]
self.format_answer = f'\({latex(self.eq1)}\)'
# self.answer_latex = latex_print(self.answer)
# self.answer_latex_display = latex_print(self.answer, display=True)
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'num_solutions' in kwargs:
self.num_solutions = kwargs['num_solutions']
else:
self.num_solutions = random.choice([0, 1, 2, 0, 1, 2, oo])
# self.num_solutions = oo
num_solutions = self.num_solutions
print('num_solutions', num_solutions)
if 'difficulty' in kwargs:
self.difficulty = kwargs['difficulty']
else:
self.difficulty = random.choice([1, 1, 2])
self.p = random_non_zero_integer(-9, 9)
self.q = random.randint(1, 5)
self.r = Rational(self.p, self.q)
if 'a' in kwargs:
self.a = kwargs['a']
else:
self.a = random.randint(1, 4)
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
d_fact = random.choice([-1, 1])
if num_solutions == oo:
e_prime = 0
self.d = self.a * d_fact
if d_fact > 0:
self.answer = Interval(self.r, oo)
self.format_answer = f'\\( x \geq {self.r} \\)'
self.ineq_answer = self.x >= self.r
else:
self.answer = Interval(-oo, self.r)
self.format_answer = f'\\( x \leq {self.r} \\)'
self.ineq_answer = self.x <= self.r
elif num_solutions == 0:
e_prime = random.randint(-9, -1)
self.d = d_fact * random.randint(1, abs(self.a))
self.format_answer = 'No Solution'
self.answer = EmptySet
elif num_solutions == 1:
e_prime = random_non_zero_integer(-9, 9)
if e_prime < 0:
self.d = d_fact * random.randint(abs(self.a) + 1, 6)
else:
self.d = d_fact * random.randint(abs(self.a), 6)
else: # num_solutions == 2:
e_prime = random.randint(1, 9)
self.d = d_fact * random.randint(1, abs(self.a))
if num_solutions in [1, 2]:
things_to_check = []
try:
x0 = Rational(e_prime, self.a - self.d) + self.r
things_to_check.append(x0)
except ZeroDivisionError:
pass
try:
x0 = Rational(-e_prime, self.a + self.d) + self.r
things_to_check.append(x0)
except ZeroDivisionError:
pass
solutions = EmptySet
for x0 in things_to_check:
lhs = self.a * abs(self.x - self.r)
rhs = self.d * (self.x - self.r) + e_prime
if lhs.subs(self.x, x0) == rhs.subs(self.x, x0):
solutions += FiniteSet(x0)
self.answer = solutions
if self.answer == EmptySet:
self.num_solutions = 0
self.format_answer = 'No Solution'
else:
fmt_answer = '\\('
for x in self.answer:
fmt_answer += f'{latex(x)}, '
fmt_answer = fmt_answer[:-2]
fmt_answer += '\\)'
self.format_answer = fmt_answer
# self.format_answer = f'\({latex(self.answer)}\)'
if 'c' in kwargs:
self.c = kwargs['c']
else:
self.c = random.randint(-9, 9)
self.e = e_prime + self.c
x = self.x
a = self.a
r = self.r
c = self.c
d = self.d
e = self.e
q = self.q
split_d = random.randint(-9, 9)
terms = [
abs(q * a * (x - r)), q * c, -q * (d + split_d) * (x - r), -q * e,
q * (split_d) * (x - r)
]
# lhs = abs(self.q*a*(x - r)) + q*c
# rhs = self.q*(d*(x - r) + e)
eq = permute_equation(terms, seed=self.seed)
self.given = eq
self.format_given = f'\\[{latex(eq)}\\]'
self.format_given_for_tex = f"""
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'logical_connector' in kwargs:
self.logical_connector = kwargs['logical_connector']
else:
self.logical_connector = random.choice(['and', 'or'])
if 'Q1' in kwargs:
self.Q1 = kwargs['Q1']
else:
signs = ['\\leq', '\\lt']
self.Q1 = random.choice(signs)
if 'Q2' in kwargs:
self.Q2 = kwargs['Q2']
else:
if self.logical_connector == 'and':
signs = ['\\leq', '\\lt']
self.Q2 = random.choice(signs)
else:
signs = ['\\geq', '\\gt']
self.Q2 = random.choice(signs)
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
if 'l' in kwargs:
self.l = kwargs['l']
else:
self.l = random.randint(-18, 15)
if 'r' in kwargs:
self.r = kwargs['r']
else:
offset_max = abs((20 - self.l)) - 2
self.r = self.l + random.randint(1, offset_max)
if 'difficulty' in kwargs:
self.difficulty = kwargs['difficulty']
else:
self.difficulty = random.choice([1, 1, 2])
if self.difficulty == '1':
self.force_same = True
else:
self.force_same = random.choice([True, False])
if self.logical_connector == 'and':
self.force_same = True
if 'a' in kwargs:
self.a = kwargs['a']
else:
self.a = random_non_zero_integer(-9, 9)
if 'b' in kwargs:
self.b = kwargs['b']
else:
self.b = random.randint(-9, 9)
if 'c' in kwargs:
self.c = kwargs['c']
else:
self.c = random.randint(-9, 9)
if self.force_same:
self.e = self.a
self.f = self.b
self.g = self.c
else:
if 'e' in kwargs:
self.e = kwargs['e']
else:
self.e = random_non_zero_integer(-9, 9)
if 'f' in kwargs:
self.f = kwargs['f']
else:
self.f = random.randint(-9, 9)
if 'g' in kwargs:
self.g = kwargs['g']
else:
self.g = random.randint(-9, 9)
self.l1 = self.a * (self.l + self.b) + self.c
if self.logical_connector == 'and':
self.r1 = self.a * (self.r + self.b) + self.c
else:
self.r1 = self.e * (self.r + self.f) + self.g
self.genproblem()
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'p' in kwargs:
self.p = kwargs['p']
else:
self.p = random_non_zero_integer(-2, 2)
if 'q' in kwargs:
self.q = kwargs['q']
else:
self.q = random.randint(1, 2)
if 'm' in kwargs:
self.m = kwargs['m']
else:
self.m = sy.Rational(self.p, self.q)
if 'x0' in kwargs:
self.x0 = kwargs['x0']
else:
self.x0 = random.randint(-5, 5)
if 'y0' in kwargs:
self.y0 = kwargs['y0']
else:
# y0_min = max(-5, -9 - self.m*4)
# y0_max = min(5, 9 - self.m*4)
y0_min = -5
y0_max = 5
self.y0 = random.randint(y0_min, y0_max)
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = sy.Symbol('x')
# if 'sign_x' in kwargs:
# self.sign_x = kwargs['sign_x']
# else:
# self.sign_x = random.choice([-1, 1])
# sign_x = self.sign_x
x = self.x
k = self.y0
h = self.x0
# p = self.p
# q = self.q
m = self.m
self.as_lambda = lambda x: m * (x - h)**3 + k
f = self.as_lambda
self.given = f(x)
#print('3rd step: So far its ', expr)
self.answer = f(x)
term = self.given
if self.y0 > 0:
fmt_y0 = sy.latex(self.y0)
sign = '+'
elif self.y0 == 0:
fmt_y0 = ''
sign = ''
else:
fmt_y0 = sy.latex(abs(self.y0))
sign = '-'
# print(term)
if self.m == 1:
fmt_m = ''
elif self.m == -1:
fmt_m = '-'
else:
fmt_m = sy.latex(self.m)
try:
self.format_given = f"""
\\(
y = {fmt_m} {sy.latex((sy.factor((self.x - self.x0))**3))} {sign} {fmt_y0}
\\)
"""
except IndexError:
self.format_given = f"""
\\(
y = {sy.latex(term)} {sign} {fmt_y0}
\\)
"""
# self.format_answer = '\\quad\n'
self.prompt_single = """Develop an equation for the given graph.
"""
self.prompt_multiple = """For each of the following,
develop an equation for the given graph."""
# f = self.as_lambda
# self.answer = f(x)
self.format_answer = self.format_given
# a = self.a
# h = self.x0
# x_points_left = [h-1, h-8]
x_points = [h, h + 1, h + 2, h - 1, h - 2]
points = [[x, f(x)] for x in x_points]
self.points = points
# self.piecewise = True
poly_points = self.get_svg_data([-10, 10])
self.format_given = f"""
<div style="text-align:center">
{render_template('_static_graph.html',
poly_points=poly_points,
parameters=get_parameters(),
points=points)}
</div>
"""
self.format_given_for_tex = f"""{self.prompt_single}
def __init__(self, **kwargs):
if 'seed' in kwargs:
self.seed = kwargs['seed']
else:
self.seed = random.random()
random.seed(self.seed)
if 'x0' in kwargs:
self.x0 = kwargs['x0']
else:
self.x0 = random_non_zero_integer(-8,8)
if 'y0' in kwargs:
self.y0 = kwargs['y0']
else:
self.y0 = random.randint(-8, 8)
if 'orientation' in kwargs:
self.orientation = kwargs['orientation']
else:
self.orientation = random.choice(['vert', 'horiz'])
if 'parallel_or_perp' in kwargs:
self.parallel_or_perp = kwargs['parallel_or_perp']
else:
self.parallel_or_perp = random.choice(['parallel', 'perpendicular'])
if self.orientation == 'vert':
self.symb = Symbol('x')
self.value = self.x0
if self.parallel_or_perp == 'parallel':
ax_name = '\(y\)'
alt_symb = 'x'
else:
ax_name = '\(x\)'
alt_symb = 'y'
else: #horiz
self.symb = Symbol('y')
self.value = self.y0
if self.parallel_or_perp == 'parallel':
ax_name = '\(x\)'
alt_symb = 'y'
else:
ax_name = '\(y\)'
alt_symb = 'x'
alt_value = random.randint(-9,9)
alt_line_choices = [
f'the {ax_name}-axis',
f'the line with equation \({alt_symb} = {alt_value}\)'
]
self.given_line = random.choice(alt_line_choices)
self.lhs = self.symb
self.rhs = self.value
# self.given = Eq(self.lhs, self.rhs)
self.answer = self.value
self.format_given = f"""
<div style="text-align:center">
The line is {self.parallel_or_perp} to {self.given_line}
and passes through \(({self.x0}, {self.y0})\).
</div>
"""
self.format_answer = '\\quad\n'
# self.answer_latex = latex_print(self.answer)
# self.answer_latex_display = latex_print(self.answer, display=True)
self.format_given_for_tex = f"""
{self.prompt_single}
\\begin{{center}}
The line is {self.parallel_or_perp} to {self.given_line}
and passes through \(({self.x0}, {self.y0})\).
\\end{{center}}
\\begin{{flushright}}
\\includegraphics[scale=0.6]{{../common_imgs/blank}}
\\end{{flushright}}
\\vspace{{-12\\baselineskip}}
"""
self.format_fragment_for_tex = f"""
