def test_f6_simplification_line(): """Is this Fraction's simplification line correct?""" assert Fraction(('+', Product([Item(10), Item(5)]), Product([Item(5), Item(9)])))\ .simplification_line().printed == \ wrap_nb('\\frac{10\\times \\bcancel{5}}{\\bcancel{5}\\times 9}')
class sub_object(object): def __init__(self, numbers_to_use, **options): nb_list = list(numbers_to_use) hole = Item(Value('...')) self.hidden_one = None visible_one = None self.product = Item(Product([nb_list[0], nb_list[1]]).evaluate()) if isinstance(nb_list[1], Fraction): self.hidden_one = nb_list[1] visible_one = nb_list[0] else: nb1 = randomly.pop(nb_list) nb2 = randomly.pop(nb_list) nb_list = [nb1, nb2] self.hidden_one = Item(randomly.pop(nb_list)) visible_one = randomly.pop(nb_list) factors = [visible_one, hole] self.holed_product = Product([randomly.pop(factors), randomly.pop(factors)]) self.holed_product.set_compact_display(False) def q(self, **options): m_expr = Equality([self.holed_product, self.product]).printed return _("Which number can fill the hole in: {math_expr}?")\ .format(math_expr=shared.machine.write_math_style2(m_expr)) def a(self, **options): return shared.machine.write_math_style2(self.hidden_one.printed)
def test_product_sum_2_3x_times_sum_minus4_6x_is_not_reducible(): """Is this Product not reducible?""" p = Product([ Sum([Item(2), Monomial(('+', 3, 1))]), Sum([Item(-4), Monomial(('+', 6, 1))]) ]) assert not p.is_reducible()
def test_f5_simplification_line(): """Is this Fraction's simplification line correct?""" assert Fraction(('+', Product([Item(8), Item(3)]), Product([Item(5), Item(6)])))\ .simplification_line().printed == \ wrap_nb('\\frac{\\bcancel{2}\\times 4\\times \\bcancel{3}}{5\\times' ' \\bcancel{2}\\times \\bcancel{3}}')
def test_f3_simplification_line(): """Is this Fraction's simplification line correct?""" assert Fraction(('+', Product([Item(7), Item(6)]), Product([Item(3), Item(3)])))\ .simplification_line().printed == \ wrap_nb('\\frac{7\\times \\bcancel{3}\\times 2}' '{\\bcancel{3}\\times 3}')
def test_product_9_times_minus2_times_7ab_printed(): """Is this Product correctly printed?""" assert Product([Item(9), Product([Item(-2), Item(7), Item('a'), Item('b')])])\ .printed == wrap_nb('9\\times (-2)\\times 7ab')
def test_fractions_by_items_01_next_step(): """Is this Product's calculation's next step correct?""" p = Product([ Fraction((Item(3), Item(5))), Item(8), Fraction((Item(7), Item(11))), Item(4), Fraction((Item(13), Item(17))) ]) assert p.calculate_next_step().printed == \ wrap_nb('\\frac{3\\times 8\\times 7\\times 4\\times 13}{5\\times 11' '\\times 17}')
def __init__(self, numbers_to_use, **options): super().setup("minimal", **options) super().setup("numbers", nb=numbers_to_use, **options) super().setup("nb_variants", nb=numbers_to_use, **options) product = Product([self.nb1, self.nb2]) self.product_str = product.printed self.result = product.evaluate() if self.context == 'mini_problem': super().setup("mini_problem_wording", q_id=os.path.splitext(os.path.basename(__file__))[0], **options)
def complicated_sum_to_reduce(): return Sum([ Monomial(('+', 3, 1)), Item(4), Sum([ Monomial(('+', 3, 1)), Monomial(('+', 5, 2)), Product([Item(-7), Item('a'), Item('b')]) ]), Product([Item('-a'), Item('b')]), Monomial(('+', 5, 2)), Item(2), Monomial(('-', 2, 1)), Product([Item(2), Item('a'), Item('b')]) ])
def __init__(self, numbers_to_use, **options): super().__init__(numbers_to_use, result_fct=lambda x, y: Product([x, y]), wording=_("How much is the quotient of {nb1} by " "{nb2}?"), permute_nb1_nb2_result=True, **options)
def big_product(): s = Sum(['x', 3]) s.set_exponent(3) p = Product(Monomial((1, 2))) p.set_exponent(3) p1 = Product([2, 3]) p1.set_exponent(3) return Product([ Monomial((2, 1)), Monomial((-4, 2)), s, Item(5), p, Item(('+', -1, 2)), p1 ])
def __init__(self, build_data, **options): super().setup("minimal", **options) super().setup("numbers", nb=build_data, **options) super().setup("nb_variants", nb=build_data, **options) self.transduration = 8 if not is_integer(self.nb1) or not is_integer(self.nb2): self.transduration = 15 product = Product([self.nb1, self.nb2]) self.product_str = product.printed self.result = product.evaluate() if self.context == 'mini_problem': self.transduration = 25 super().setup('mini_problem_wording', q_id=os.path.splitext(os.path.basename(__file__))[0], **options)
def __init__(self, numbers_to_use, **options): MULTIPLE_QUESTIONS = {2: _("What is the double of {nb1}?"), 3: _("What is the triple of {nb1}?"), 4: _("What is the quadruple of {nb1}?")} super().__init__(numbers_to_use, result_fct=lambda x, y: Product([x, y]), wording=MULTIPLE_QUESTIONS[numbers_to_use[0]], shuffle_nbs=False, swap_nb1_nb2=True)
def __init__(self, numbers_to_use, **options): PARTS_QUESTIONS = { 2: _("What is the half of {nb1}?"), 3: _("What is the third of {nb1}?"), 4: _("What is the quarter of {nb1}?") } super().__init__(numbers_to_use, result_fct=lambda x, y: Product([x, y]), wording=PARTS_QUESTIONS[numbers_to_use[0]], shuffle_nbs=False, permute_nb1_nb2_result=True)
def __init__(self, numbers_to_use, **options): nb_list = list(numbers_to_use) hole = Item(Value('...')) self.hidden_one = None visible_one = None self.product = Item(Product([nb_list[0], nb_list[1]]).evaluate()) if isinstance(nb_list[1], Fraction): self.hidden_one = nb_list[1] visible_one = nb_list[0] else: nb1 = randomly.pop(nb_list) nb2 = randomly.pop(nb_list) nb_list = [nb1, nb2] self.hidden_one = Item(randomly.pop(nb_list)) visible_one = randomly.pop(nb_list) factors = [visible_one, hole] self.holed_product = Product([randomly.pop(factors), randomly.pop(factors)]) self.holed_product.set_compact_display(False)
def neg2_inside_exp_sum_of_product_of_1plus1(): return Item(('+', -2, Sum([Product([Sum([1, 1])])])))
def test_neg2_inside_exp_sum_of_product_of_1plus0_printed(): """Is Item(('+', -2, Sum([Product([Sum([1, 0])])]))) correctly printed?""" assert Item(('+', -2, Sum([Product([Sum([1, 0])])]))).printed == \ wrap_nb('-2')
def test_neg2_inside_exp_sum_of_product_of_sum_of_2_printed(): """Is Item(('+', -2, Sum([Product([Sum([2])])]))) correctly printed?""" assert Item(('+', -2, Sum([Product([Sum([2])])]))).printed == \ wrap_nb('(-2)^{2}')
def test_complicated_sum_01(): """Is this Sum correctly printed as 2-10x^{2}+9?""" assert Sum([Item(2), Product([Polynomial([Monomial(('-', 10, 2)), Monomial(('+', 9, 0))])])]).printed == \ wrap_nb('2-10x^{2}+9')
def __init__(self, numbers_to_use, picture='true', **options): super().setup("minimal", **options) if numbers_to_use[0] < 11: raise ValueError('numbers_to_use[0] == {} whereas it should be ' '>= 11'.format(str(numbers_to_use[0]))) numbers_to_use = (numbers_to_use[0] / 10, ) + numbers_to_use[1:] super().setup("numbers", nb=numbers_to_use, shuffle_nbs=False, **options) super().setup("length_units", **options) super().setup("intercept_theorem_figure", butterfly=True, **options) self.figure.setup_labels([True, False, True, True, False, True], segments_list=self.figure.small + self.figure.side) self.line1 = self.figure.small[1].length_name self.line2 = self.figure.side[1].length_name self.wording = _('The drawn figure is out of shape. {newline} ' 'The lengths are given in {length_unit}. ' '{newline} {newline} ' 'Prove that {line1} is parallel to {line2}.') setup_wording_format_of(self) self.ratio1 = shared.machine.write_math_style1( Equality([ Quotient(('+', self.figure.small[0].length_name, self.figure.side[0].length_name)), Quotient(('+', self.figure.small[0].length, self.figure.side[0].length)) ]).printed) self.ratio2 = shared.machine.write_math_style1( Equality([ Quotient(('+', self.figure.small[2].length_name, self.figure.side[2].length_name)), Quotient(('+', self.figure.small[2].length, self.figure.side[2].length)) ]).printed) self.crossproduct = shared.machine.write_math_style1( Equality([ Quotient(('+', Product([ Item(self.figure.small[0].length), Item(self.figure.side[2].length) ]), Item(self.figure.side[0].length))), Item(self.figure.small[2].length) ]).printed) self.equal_ratios = shared.machine.write_math_style1( self.figure.ratios_for_converse().into_str( as_a_quotients_equality=True)) ans_variant = options.get('ans_variant', 'default') ans_texts = { 'default': _('\\begin{tabular}{ll}' 'We have: & ' '{main_vertex_name} {belongs_to} {chunk0_length_name}' ' \\\\ ' ' & ' '{main_vertex_name} {belongs_to} {chunk1_length_name}' ' \end{tabular}'), 'alternative2': _('{vertex1_name}, {main_vertex_name} and ' '{point0_name} on one hand, ' '{vertex2_name}, {main_vertex_name} and ' '{point1_name} on the other hand,' 'are aligned in the same order. ') } ratios = _('\\begin{multicols}{2} ' 'On one hand: {ratio1} ' 'and on the other hand: {ratio2} ' '\end{multicols} ' 'ans as: {crossproduct} ' 'then: {equal_ratios} {newline} ') conclusion = _('Hence by the converse of the intercept theorem, ' '{line1} is parallel to {line2}.') self.answer_wording = ans_texts[ans_variant] + ratios + conclusion setup_wording_format_of(self, w_prefix='answer_')
def fp1(): return Product([Fraction((14, 7)), Fraction((12, 12))]) @pytest.fixture
def test_sum_3squareplus5(): """Is this Sum correctly printed as 3^{2}+5?""" p = Product([Item(3)]) p.set_exponent(2) assert Sum([p, Item(5)]).printed == wrap_nb('3^{2}+5')
def __init__(self, q_kind='default_nothing', **options): self.derived = True # The call to the mother class __init__() method will set the # fields matching optional arguments which are so far: # self.q_kind, self.q_subkind # plus self.options (modified) Q_Structure.__init__(self, q_kind, AVAILABLE_Q_KIND_VALUES, **options) # The purpose of this next line is to get the possibly modified # value of **options options = self.options init_caller = INIT_CALLER[q_kind] self.expandable_objct = None self.numeric_aux = None if q_kind == 'any_basic_expd': randomly_drawn = randomly.decimal_0_1() if randomly_drawn <= 0.25: self.expandable_objct = Expandable((RANDOMLY, 'monom0_polyn1'), randomly_reversed=0.5) elif randomly_drawn <= 0.50: self.expandable_objct = Expandable((RANDOMLY, 'monom1_polyn1'), randomly_reversed=0.5) else: self.expandable_objct = Expandable((RANDOMLY, 'polyn1_polyn1')) elif q_kind in ['monom0_polyn1', 'monom1_polyn1']: self.expandable_objct = Expandable((RANDOMLY, q_kind), randomly_reversed=0.5) elif q_kind == 'monom01_polyn1': self.expandable_objct = Expandable( (RANDOMLY, randomly.pop(['monom0_polyn1', 'monom1_polyn1'])), randomly_reversed=0.5) elif q_kind == 'polyn1_polyn1': self.expandable_objct = Expandable((RANDOMLY, 'polyn1_polyn1')) elif q_kind == 'sum_of_any_basic_expd': if self.q_subkind in ['harder', 'with_a_binomial']: # __ choices = ['monom0_polyn1', 'monom1_polyn1'] drawn_types = list() drawn_types.append(randomly.pop(choices)) if self.q_subkind == 'with_a_binomial': drawn_types.append('any_binomial') else: drawn_types.append('minus_polyn1_polyn1') aux_expd_list = list() for t in drawn_types: if t == 'any_binomial': aux_expd_list.append( BinomialIdentity((RANDOMLY, 'any'), **options)) else: aux_expd_list.append(Expandable((RANDOMLY, t))) final_list = list() for i in range(len(aux_expd_list)): final_list.append(randomly.pop(aux_expd_list)) self.expandable_objct = Sum(final_list) elif self.q_subkind == 'easy': choices = ['monom0_polyn1', 'monom1_polyn1'] aux_expd_list = list() aux_expd_list.append( Expandable((RANDOMLY, randomly.pop(choices)))) if randomly.heads_or_tails(): aux_expd_list.append(Expandable((RANDOMLY, 'sign_exp'))) else: aux_expd_list.append( Monomial((RANDOMLY, 15, randomly.integer(0, 2)))) final_list = list() for i in range(len(aux_expd_list)): final_list.append(randomly.pop(aux_expd_list)) self.expandable_objct = Sum(final_list) else: choices = [ 'monom0_polyn1', 'monom0_polyn1', 'monom1_polyn1', 'monom1_polyn1', 'polyn1_polyn1', 'minus_polyn1_polyn1' ] drawn_types = list() drawn_types.append(randomly.pop(choices)) drawn_types.append(randomly.pop(choices)) aux_expd_list = list() for element in drawn_types: aux_expd_list.append(Expandable((RANDOMLY, element))) aux_expd_list.append(Monomial((RANDOMLY, 15, 2))) final_list = list() for i in range(len(aux_expd_list)): final_list.append(randomly.pop(aux_expd_list)) self.expandable_objct = Sum(final_list) elif q_kind in ['sign_expansion', 'sign_expansion_short_test']: sign_exp_kind = options.get('sign_exp_kind', 0) if q_kind == 'sign_expansion_short_test': sign_exp_kind = 1 if sign_exp_kind == 0: sign_exp_kind = randomly.integer(1, 5) # Creation of the terms aux_terms_list = list() aux_expd_1 = Expandable((Monomial( (randomly.sign(), 1, 0)), Polynomial((RANDOMLY, 15, 2, 2)))) aux_expd_2 = Expandable((Monomial( (randomly.sign(), 1, 0)), Polynomial((RANDOMLY, 15, 2, 2)))) aux_expd_3 = Expandable((Monomial( (randomly.sign(), 1, 0)), Polynomial((RANDOMLY, 15, 2, 2)))) long_aux_expd = Expandable((Monomial( (randomly.sign(), 1, 0)), Polynomial((RANDOMLY, 15, 2, 3)))) if q_kind == 'sign_expansion_short_test': long_aux_expd = Expandable((Monomial( ('-', 1, 0)), Polynomial((RANDOMLY, 15, 2, 3)))) aux_monomial = Monomial((RANDOMLY, 15, 2)) # 1st kind: a Monomial and ± (long Polynomial) # (like in a short test) if sign_exp_kind == 1: aux_terms_list.append(long_aux_expd) aux_terms_list.append(aux_monomial) # 2d kind: ± (x+3) ± (4x - 7) elif sign_exp_kind == 2: aux_terms_list.append(aux_expd_1) aux_terms_list.append(aux_expd_2) # 3d kind: ± (x+3) ± (4x - 7) ± (x² - 5x) elif sign_exp_kind == 3: aux_terms_list.append(aux_expd_1) aux_terms_list.append(aux_expd_2) aux_terms_list.append(aux_expd_3) # 4th kind: ± (x+3) ± (4x - 7) ± Monomial elif sign_exp_kind == 4: aux_terms_list.append(aux_expd_1) aux_terms_list.append(aux_expd_2) aux_terms_list.append(aux_monomial) # 5th kind: ± (x+3) ± Monomial ± (long Polynomial) elif sign_exp_kind == 5: aux_terms_list.append(aux_expd_2) aux_terms_list.append(aux_monomial) aux_terms_list.append(long_aux_expd) # add as many possibilities as wanted, # don't forget to increase the last number here: # sign_exp_kind = randomly.integer(1, 5) (what's a bit above) # Now let's distribute the terms randomly final_terms_list = list() for i in range(len(aux_terms_list)): final_terms_list.append(randomly.pop(aux_terms_list)) self.expandable_objct = Sum(final_terms_list) elif q_kind in [ 'numeric_sum_square', 'numeric_difference_square', 'numeric_squares_difference' ]: # __ self.expandable_objct = init_caller( (options['couple'][0], options['couple'][1]), **options) if q_kind in ['numeric_sum_square', 'numeric_difference_square']: self.numeric_aux = Sum( [options['couple'][0], options['couple'][1]]).reduce_() self.numeric_aux.set_exponent(2) else: # squares_difference's case aux1 = Sum([options['couple'][0], options['couple'][1]]).reduce_() temp = options['couple'][1].clone() temp.set_sign('-') aux2 = Sum([options['couple'][0], temp]).reduce_() self.numeric_aux = Product([aux1, aux2]) else: if q_kind == 'any_binomial': q_kind = 'any' self.expandable_objct = init_caller((RANDOMLY, q_kind), **options) # Creation of the expression: number = 0 if 'expression_number' in options \ and is_.a_natural_int(options['expression_number']): # __ number = options['expression_number'] self.expression = Expression(number, self.expandable_objct) if self.numeric_aux is not None: self.numeric_aux = Expression(number, self.numeric_aux)
def __init__(self, numbers_to_use, **options): super().setup("minimal", **options) if self.variant == 'with_a_decimal': second_couple = shared.mc_source.next('int_deci_clever_pairs') elif self.variant == 'integers_only': second_couple = shared.mc_source.next('intpairs_2to500', clever_in=[4, 5]) elif self.variant == 'fifths_series': second_couple = shared.mc_source.next('intpairs_2to500', clever=5, union={ 'table_name': 'int_deci_clever_pairs', 'clever': 5 }) elif self.variant == 'quarters_series': second_couple = shared.mc_source.next('intpairs_2to500', clever=4, union={ 'table_name': 'int_deci_clever_pairs', 'clever': 4 }) else: second_couple = shared.mc_source.next( 'intpairs_2to500', clever_in=[4, 5, 10], union={'table_name': 'int_deci_clever_pairs'}) # We shuffle the numbers in a special way if len(numbers_to_use) == 1: # There is only one number in addition to the 2 special ones # so either we put it in the first place, or in the middle # (not at the end, otherwise, the 2 special ones would be at the # two first places) special_ones = list(second_couple) random.shuffle(special_ones) all_nb = [list(numbers_to_use).pop(0), special_ones.pop(0)] random.shuffle(all_nb) all_nb += [special_ones.pop(0)] else: # It is assumed there are 2 numbers_to_use (so 4 altogether) # In order to avoid having the two "special" numbers in a row at # the two first places, we will shuffle all numbers in a special # way. if random.choice([True, False]): # In this case, the first number will NOT be from the "special" # ones, so no matter what follows nb_to_use = list(numbers_to_use) random.shuffle(nb_to_use) all_nb = [nb_to_use.pop(0)] remaining = nb_to_use + list(second_couple) else: # In this case, it will, so, at the second place we put a # number from the other source (the user specified one) first_couple = list(numbers_to_use) random.shuffle(first_couple) nb_to_use = list(second_couple) random.shuffle(nb_to_use) all_nb = [nb_to_use.pop(0), first_couple.pop(0)] remaining = nb_to_use + first_couple random.shuffle(remaining) all_nb += remaining super().setup("numbers", nb=all_nb, shuffle_nbs=False, **options) product = Product( [getattr(self, 'nb' + str(i + 1)) for i in range(self.nb_nb)]) self.product_str = product.printed self.result = product.evaluate()
def __init__(self, q_kind='default_nothing', **options): self.derived = True # The call to the mother class __init__() method will set the # fields matching optional arguments which are so far: # self.q_kind, self.q_subkind # plus self.options (modified) Q_Structure.__init__(self, q_kind, AVAILABLE_Q_KIND_VALUES, **options) # The purpose of this next line is to get the possibly modified # value of **options options = self.options # That's the number of the question, not of the expressions it might # contain ! self.number = "" if 'number_of_questions' in options: self.number = options['number_of_questions'] self.objct = None # 1st OPTION if q_kind == 'fraction_simplification': root = randomly.integer(2, 19, weighted_table=[ 0.225, 0.225, 0, 0.2, 0, 0.2, 0, 0, 0, 0.07, 0, 0.0375, 0, 0, 0, 0.0375, 0, 0.005 ]) factors_list = [j + 1 for j in range(10)] ten_power_factor1 = 1 ten_power_factor2 = 1 if 'with_ten_powers' in options \ and is_.a_number(options['with_ten_powers']) \ and options['with_ten_powers'] <= 1 \ and options['with_ten_powers'] >= 0: # __ if randomly.decimal_0_1() < options['with_ten_powers']: ten_powers_list = [10, 10, 100, 100] ten_power_factor1 = randomly.pop(ten_powers_list) ten_power_factor2 = randomly.pop(ten_powers_list) self.objct = Fraction( ('+', root * randomly.pop(factors_list) * ten_power_factor1, root * randomly.pop(factors_list) * ten_power_factor2)) # 2d & 3d OPTIONS # Fractions Products | Quotients elif q_kind in ['fractions_product', 'fractions_quotient']: # In some cases, the fractions will be generated # totally randomly if randomly.decimal_0_1() < 0: lil_box = [n + 2 for n in range(18)] a = randomly.pop( lil_box, weighted_table=FRACTION_PRODUCT_AND_QUOTIENT_TABLE) b = randomly.pop( lil_box, weighted_table=FRACTION_PRODUCT_AND_QUOTIENT_TABLE) lil_box = [n + 2 for n in range(18)] c = randomly.pop( lil_box, weighted_table=FRACTION_PRODUCT_AND_QUOTIENT_TABLE) d = randomly.pop( lil_box, weighted_table=FRACTION_PRODUCT_AND_QUOTIENT_TABLE) f1 = Fraction((randomly.sign(plus_signs_ratio=0.75), Item((randomly.sign(plus_signs_ratio=0.80), a)), Item( (randomly.sign(plus_signs_ratio=0.80), b)))) f2 = Fraction((randomly.sign(plus_signs_ratio=0.75), Item((randomly.sign(plus_signs_ratio=0.80), c)), Item( (randomly.sign(plus_signs_ratio=0.80), d)))) # f1 = f1.simplified() # f2 = f2.simplified() # In all other cases (80%), we'll define a "seed" a plus two # randomly numbers i and j to form the Product | Quotient: # a×i / b × c / a × j # Where b is a randomly number coprime to a×i # and c is a randomly number coprime to a×j else: a = randomly.integer(2, 8) lil_box = [i + 2 for i in range(7)] i = randomly.pop(lil_box) j = randomly.pop(lil_box) b = randomly.coprime_to(a * i, [n + 2 for n in range(15)]) c = randomly.not_coprime_to(b, [n + 2 for n in range(30)], excepted=a * j) f1 = Fraction( (randomly.sign(plus_signs_ratio=0.75), Item((randomly.sign(plus_signs_ratio=0.80), a * i)), Item((randomly.sign(plus_signs_ratio=0.80), b)))) f2 = Fraction( (randomly.sign(plus_signs_ratio=0.75), Item((randomly.sign(plus_signs_ratio=0.80), c)), Item((randomly.sign(plus_signs_ratio=0.80), a * j)))) if randomly.heads_or_tails(): f3 = f1.clone() f1 = f2.clone() f2 = f3.clone() if q_kind == 'fractions_quotient': f2 = f2.invert() if q_kind == 'fractions_product': self.objct = Product([f1, f2]) elif q_kind == 'fractions_quotient': self.objct = Quotient(('+', f1, f2, 1, 'use_divide_symbol')) # 4th OPTION # Fractions Sums elif q_kind == 'fractions_sum': randomly_position = randomly\ .integer(0, 16, weighted_table=FRACTIONS_SUMS_SCALE_TABLE) chosen_seed_and_generator = FRACTIONS_SUMS_TABLE[randomly_position] seed = randomly.integer(2, chosen_seed_and_generator[1]) # The following test is only intended to avoid having "high" # results too often. We just check if the common denominator # will be higher than 75 (arbitrary) and if yes, we redetermine # it once. We don't do it twice since we don't want to totally # forbid high denominators. if seed * chosen_seed_and_generator[0][0] \ * chosen_seed_and_generator[0][1] >= 75: # __ seed = randomly.integer(2, chosen_seed_and_generator[1]) lil_box = [0, 1] gen1 = chosen_seed_and_generator[0][lil_box.pop()] gen2 = chosen_seed_and_generator[0][lil_box.pop()] den1 = Item(gen1 * seed) den2 = Item(gen2 * seed) temp1 = randomly.integer(1, 20) temp2 = randomly.integer(1, 20) num1 = Item(temp1 // gcd(temp1, gen1 * seed)) num2 = Item(temp2 // gcd(temp2, gen2 * seed)) f1 = Fraction((randomly.sign(plus_signs_ratio=0.7), num1, den1)) f2 = Fraction((randomly.sign(plus_signs_ratio=0.7), num2, den2)) self.objct = Sum([f1.simplified(), f2.simplified()]) # 5th # still to imagine:o) # Creation of the expression: number = 0 if 'expression_number' in options \ and is_.a_natural_int(options['expression_number']): # __ number = options['expression_number'] self.expression = Expression(number, self.objct)
def __init__(self, numbers_to_use, **options): nb_list = list(numbers_to_use) self.nb1, self.nb2 = random.sample(nb_list, 2) self.product = Product([self.nb1, self.nb2]).evaluate()
def a(self, **options): if self.product == 12: return _("{product1} or {product2}")\ .format(product1=shared.machine.write_math_style2( Product([2, 6]).printed), product2=shared.machine.write_math_style2( Product([3, 4]).printed)) elif self.product == 16: return _("{product1} or {product2}")\ .format(product1=shared.machine.write_math_style2( Product([2, 8]).printed), product2=shared.machine.write_math_style2( Product([4, 4]).printed)) elif self.product == 18: return _("{product1} or {product2}")\ .format(product1=shared.machine.write_math_style2( Product([2, 9]).printed), product2=shared.machine.write_math_style2( Product([3, 6]).printed)) elif self.product == 24: return _("{product1} or {product2}")\ .format(product1=shared.machine.write_math_style2( Product([3, 8]).printed), product2=shared.machine.write_math_style2( Product([4, 6]).printed)) elif self.product == 36: return _("{product1} or {product2}")\ .format(product1=shared.machine.write_math_style2( Product([6, 6]).printed), product2=shared.machine.write_math_style2( Product([4, 9]).printed)) else: return shared.machine.write_math_style2( Product([self.nb1, self.nb2]).printed)
def test_sum_neg1plusx_bis(): """Is this Sum correctly printed as -1+x?""" assert Sum([Product(Item(-1)), Item('x')]).printed == wrap_nb('-1+x')
def test_sum_1plusx(): """Is this Sum correctly printed as 1+x?""" assert Sum([Product(Item(1)), Item('x')]).printed == wrap_nb('1+x')
def fp0(): return Product([Fraction((5, 4)), Fraction((5, 5))]) @pytest.fixture
def test_sum_3squareplus5(): """Is this Sum correctly printed as 3^{2}+5?""" p = Product([Item(3)]) p.set_exponent(2) assert Sum([p, Item(5)]).printed == wrap_nb('3^{2}+5')
def fp2(): return Product([Fraction((9, -2)), Fraction((-8, 10))]) @pytest.fixture
def __init__(self, build_data, **options): super().setup("minimal", **options) if self.variant == 'with_a_decimal': second_couple = shared.mc_source.next('int_deci_clever_pairs') elif self.variant == 'integers_only': second_couple = shared.mc_source.next('intpairs_2to500', clever_in=[4, 5]) elif self.variant == 'fifths_series': second_couple = shared.mc_source.next('intpairs_2to500', clever=5, union={ 'table_name': 'int_deci_clever_pairs', 'clever': 5}) elif self.variant == 'quarters_series': second_couple = shared.mc_source.next('intpairs_2to500', clever=4, union={ 'table_name': 'int_deci_clever_pairs', 'clever': 4}) else: second_couple = shared.mc_source.next('intpairs_2to500', clever_in=[4, 5, 10], union={ 'table_name': 'int_deci_clever_pairs'}) # We shuffle the numbers in a special way if len(build_data) == 1: # There is only one number in addition to the 2 special ones # so either we put it in the first place, or in the middle # (not at the end, otherwise, the 2 special ones would be at the # two first places) special_ones = list(second_couple) random.shuffle(special_ones) all_nb = [list(build_data).pop(0), special_ones.pop(0)] random.shuffle(all_nb) all_nb += [special_ones.pop(0)] else: # It is assumed there are 2 build_data (so 4 altogether) # In order to avoid having the two "special" numbers in a row at # the two first places, we will shuffle all numbers in a special # way. if random.choice([True, False]): # In this case, the first number will NOT be from the "special" # ones, so no matter what follows nb_to_use = list(build_data) random.shuffle(nb_to_use) all_nb = [nb_to_use.pop(0)] remaining = nb_to_use + list(second_couple) else: # In this case, it will, so, at the second place we put a # number from the other source (the user specified one) first_couple = list(build_data) random.shuffle(first_couple) nb_to_use = list(second_couple) random.shuffle(nb_to_use) all_nb = [nb_to_use.pop(0), first_couple.pop(0)] remaining = nb_to_use + first_couple random.shuffle(remaining) all_nb += remaining super().setup("numbers", nb=all_nb, shuffle_nbs=False, **options) self.transduration = 15 product = Product([getattr(self, 'nb' + str(i + 1)) for i in range(self.nb_nb)]) self.product_str = product.printed self.result = product.evaluate()