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"""