def genproblem(self):
out = {}
x = self.x
a = self.a
b = self.b
c = self.c
d = self.d
e = self.e
f = self.f
terms = [factor(a * (x + b)), factor(c * (x + d)), e * x, f]
if self.num_solutions in [0, oo]:
LHS, RHS = permute_equation(terms, as_list=True)
out['given'] = f'{latex(LHS)} = {latex(RHS)}'
else:
out['given'] = permute_equation(terms)
#print('3rd step: So far its ', expr)
if self.num_solutions == 1:
out['answer'] = Rational(-(a * b + c * d + f), (a + c + e))
elif self.num_solutions == 0:
out['answer'] = 'No solution'
else:
out['answer'] = 'All real numbers'
return out
def genproblem(self):
out = {}
x = self.x
a = self.a
b = self.b
c = self.c
d = self.d
e = self.e
f = self.f
if self.difficulty == 2:
term1 = factor(a * (x + b))
else:
term1 = a * (x + b)
if self.difficulty == 3:
term2 = factor(c * (x + d))
else:
term2 = c * (x + d)
terms = [term1, term2, e * x, f]
LHS, RHS = permute_equation(terms, as_list=True)
Q = self.Q
self.given_latex_display = f'\\[ \n \t {latex(LHS)} {Q} {latex(RHS)} \n \\]'
self.format_given = self.given_latex_display
self.format_given_for_tex = f"""
{self.prompt_single}
\\[ \n \t {latex(LHS)} {Q} {latex(RHS)} \n \\]
"""
self.given = [LHS, RHS]
#print('3rd step: So far its ', expr)
bdry = Rational(-(a * b + c * d + f), a + c + e)
if a + c + e < 0:
Q = BasicFunctionFromTable.switchQ(Q)
if Q == '\\lt':
self.answer = Interval.Ropen(-oo, bdry)
self.ineq_answer = x < bdry
if Q == '\\leq':
self.answer = Interval(-oo, bdry)
self.ineq_answer = x <= bdry
if Q == '\\gt':
self.answer = Interval.Lopen(bdry, oo)
self.ineq_answer = x > bdry
if Q == '\\geq':
self.answer = Interval(bdry, oo)
self.ineq_answer = x >= bdry
self.format_answer = f'\\( x {Q} {latex(bdry)} \\)'
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 '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 'has_solutions' in kwargs:
self.has_solutions = kwargs['has_solutions']
else:
self.has_solutions = random.choice([True, True, False])
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 'sqr' in kwargs:
self.sqr = kwargs['sqr']
else:
if self.has_solutions:
p = random.randint(0, 9)
q = random.choice([1, 1, 1, 2, 3])
self.sqr = sy.Rational(p, q)
else:
p = random.randint(-9, -1)
q = random.choice([1, 1, 1, 2, 3])
self.sqr = sy.Rational(p, q)
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = sy.Symbol('x')
x = self.x
a = self.a
b = self.b
c = self.c
sqr = self.sqr
d = a * self.sqr + c
self.d = d
terms = [q * sy.factor(a * (x - b)**2), q * c, -d * q]
if not self.has_solutions:
LHS, RHS = permute_equation(terms, as_list=True)
self.given = f'{sy.latex(LHS)} = {sy.latex(RHS)}'
else:
self.given = permute_equation(terms)
#print('3rd step: So far its ', expr)
if self.has_solutions:
self.answer = {-sy.sqrt(sqr) + b, sy.sqrt(sqr) + b}
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.given_latex = latex_print(self.given)
self.given_latex_display = latex_print(self.given, display=True)
self.format_given = self.given_latex_display
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 'force_no_solution' in kwargs:
self.force_no_solution = kwargs['force_no_solution']
else:
self.force_no_solution = random.choice([False, False, False, True])
if 'force_infinite_solutions' in kwargs:
self.force_infinite_solutions = kwargs['force_infinite_solutions']
else:
if not self.force_no_solution:
self.force_infinite_solutions = random.choice(
[False, False, False, True])
else:
self.force_infinite_solutions = False
if 'a' in kwargs:
self.a = kwargs['a']
else:
self.a = random_non_zero_integer(-6, 6)
if 'b' in kwargs:
self.b = kwargs['b']
else:
self.b = random.randint(-6, 6)
if 'c' in kwargs:
self.c = kwargs['c']
else:
self.c = random.randint(-9, 9)
if 'e' in kwargs:
self.e = kwargs['e']
else:
self.e = random.randint(-9, 9)
if 'sign' in kwargs:
self.sign = kwargs['sign']
else:
self.sign = random.choice([-1, 1])
if self.force_no_solution:
self.c = random_non_zero_integer(-9, 9)
self.d = self.a
while self.e == self.b:
self.e = random.randint(-9, 9)
self.c = abs(self.e - self.b) + random.randint(1, 9)
elif self.force_infinite_solutions:
self.c = random_non_zero_integer(-9, 9)
self.d = self.a
while self.e == self.b:
self.e = random.randint(-9, 9)
self.c = self.a * (self.e - self.b)
if 'x' in kwargs:
self.x = kwargs['x']
else:
self.x = Symbol('x')
x = self.x
a = self.a
b = self.b
c = self.c
d = self.d
e = self.e
lhs = abs(a * x + b) + c
rhs = abs(d * x + e)
solutions = []
if a != d:
x0 = Rational((e - b - c), (a - d))
if lhs.subs(x, x0) == rhs.subs(x, x0):
solutions.append(x0)
x0 = Rational((e + b - c), (a - d))
if lhs.subs(x, x0) == rhs.subs(x, x0):
solutions.append(x0)
else:
if -e + b + c == 0:
if c < 0:
self.ineq_answer = x >= Rational(-e, d)
elif c == 0:
self.answer = 'All real numbers'
else:
self.ineq_answer = x >= Rational(-b, a)
if a != -d:
x0 = Rational((-e - b - c), (a + d))
if lhs.subs(x, x0) == rhs.subs(x, x0):
solutions.append(x0)
x0 = Rational((e + b - c), (a + d))
if lhs.subs(x, x0) == rhs.subs(x, x0):
solutions.append(x0)
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)}\)'
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"""