def testReprExpression(self): expression = ExpressionBuilder().constant_fraction( 1, 2).variable_fraction('x', -2, 3).build() self.assertEqual( repr(expression), 'Expression([Constant(Fraction(1, 2)), Variable(\'x\', Fraction(-2, 3))])' ) expression = ExpressionBuilder().constant_fraction( 1, 1).variable_fraction('x', -2, 2).build() self.assertEqual( repr(expression), 'Expression([Constant(Fraction(1, 1)), Variable(\'x\', Fraction(-1, 1))])' ) expression = ExpressionBuilder().constant_fraction( 0, 1).variable_fraction('x', 0, 2).build() self.assertEqual(repr(expression), 'Expression([Constant(Fraction(0, 1))])') expression = ExpressionBuilder().variable_fraction( 'x', 0, 2).variable_fraction('x', 0, 2).build() self.assertEqual(repr(expression), 'Expression([Variable(\'x\', Fraction(0, 1))])') expression = ExpressionBuilder().variable_fraction( 'x', 0, 2).constant_fraction(0, 2).build() self.assertEqual(repr(expression), 'Expression([Variable(\'x\', Fraction(0, 1))])')
def apply(self, name, value): self.apply_operation( Equation.EquationApplier( name, Equation( ExpressionBuilder().variable_fraction(name, 1, 1).build(), ExpressionBuilder().constant(value).build())))
def testGivenTwoExpressionsWithDifferentConstantTermsThatSumTheSameValueWhenEqualThenReturnsFalse( self): constant = ConstantBuilder().build() double_constant = constant.clon() double_constant.multiply(2.0) self.assertFalse( ExpressionBuilder().term(double_constant).build().equal( ExpressionBuilder().term(constant).term(constant).build()))
def __init__(self, left_expression=None, right_expression=None): self._expression = { Side.left: ExpressionBuilder().build(), Side.right: ExpressionBuilder().build() } if left_expression: self._expression[Side.left] = left_expression if right_expression: self._expression[Side.right] = right_expression
def testGivenExpressionWithOneVariableWhenAddExpressionWithOtherVariableAndConstantThenExpressionContainsAllTerms( self): variable1 = VariableBuilder().name('x').build() variable2 = VariableBuilder().name('y').build() constant = ConstantBuilder().value(1.0).build() expression1 = ExpressionBuilder().term(variable1).build() expression2 = ExpressionBuilder().term(variable2).term( constant).build() expression1.add_expression(expression2) self.assertEqual(expression1.get_name_set(), {variable1.name, variable2.name}) self.assertEqual(expression1.get_value_constant(), constant.value)
def testGivenExpressionWithVariableToReplaceWhenApplyExpressionThenResultantExpressionIsCorrect( self): expression = ExpressionBuilder().variable_fraction( 'x', 3, 1).variable_fraction('y', 2, 1).constant_fraction(1, 2).build() expression2 = ExpressionBuilder().variable_fraction( 'y', 2, 1).constant_fraction(1, 2).build() expression.apply_expression('x', expression2) self.assertEqual( expression, ExpressionBuilder().variable_fraction('y', 6, 1).constant_fraction( 3, 2).variable_fraction('y', 2, 1).constant_fraction(1, 2).build())
def testGivenNotEmptyExpressionWhenClonThenExpressionEqualsReturnsTrue( self): expression = ExpressionBuilder().default_constant().default_variable( ).default_variable().build() expression_clon = expression.clon() self.assertFalse(expression is expression_clon) self.assertTrue(expression.equal(expression_clon))
def testGivenExpressionWithTwoVariablesWithSameNameWhenApplyAndSimplifyThenGetValueReturnsCorrectValue( self): expression = ExpressionBuilder().term(VariableBuilder().name('x').value(3.0).build()). \ term(VariableBuilder().name('x').value(2.0).build()).build() expression.apply('x', 1.0) expression.simplify_constant() self.assertEqual(expression.get_value_constant(), 5.0)
def testGivenExpressionWithVariableWhenMultiplyBy0ThenExpressionWithConstant0IsObtained( self): variable = VariableBuilder().build() expression = ExpressionBuilder().term(variable).build() expression.multiply(0.0) self.assertEqual(expression.get_value_constant(), 0) self.assertEqual(expression.get_value_variable(variable.name), 0.0)
def testGivenExpressionWithOneVariableWhenSimplifyNameThenSameExpressionIsObtained( self): variable = VariableBuilder().build() expression = ExpressionBuilder().term(variable).build() expression2 = expression.clon() expression.simplify_variable(variable.name) self.assertTrue(expression.equal(expression2))
def testGivenExpressionWithVariableWhenAddZeroValueVariableThenNoVariableIsAdded( self): expression = ExpressionBuilder().default_variable().build() expression_original = expression.clon() zero = VariableBuilder().value(0).build() expression.add_term(zero) self.assertEqual(str(expression), str(expression_original))
def testGivenExpressionWithTwoConstantsWhenSimplifyThenExpressionWithOneConstantWithCorrectValueIsObtained( self): constant1 = ConstantBuilder().build() expression = ExpressionBuilder().term(constant1).term( constant1).build() expression.simplify_constant() self.assertTrue(expression.get_value_constant(), 2 * constant1.value)
def testGivenExpressionWithTwoVariablesSameNameWhenSimplifyThenExpressionWithOneVariableWithCorrectValueIsObtained( self): variable1 = VariableBuilder().name('x').build() expression = ExpressionBuilder().term(variable1).term(variable1).term( VariableBuilder().name('y').build()).default_constant().build() expression.simplify_variable(variable1.name) self.assertTrue(expression.get_value_variable(variable1.name), 2 * variable1.value)
def testGivenExpressionWithTwoVariablesWithDifferentNameWhenGetNameSetThenSetWithVariablesNamesIsReturned( self): variable1 = VariableBuilder().name('x').build() variable2 = VariableBuilder().name('y').build() expression = ExpressionBuilder().term(variable1).term( variable2).build() self.assertEqual(expression.get_name_set(), {variable1.name, variable2.name})
def testGivenExpressionWithTwoConstantsWithInverseValuesWhenSimplifyThenExpressionWithConstantWithValue0IsObtained( self): constant1 = ConstantBuilder().build() constant2 = constant1.clon() constant2.multiply(-1.0) expression = ExpressionBuilder().term(constant1).term( constant2).build() expression.simplify_constant() self.assertEqual(expression.get_value_constant(), 0.0)
def testGivenExpressionWithTwoVariablesWithInverseValuesWhenSimplifyThenExpressionWithNoVariablesAndConstantWithValue0IsObtained( self): variable1 = VariableBuilder().build() variable2 = variable1.clon() variable2.multiply(-1.0) expression = ExpressionBuilder().term(variable1).term( variable2).build() expression.simplify_variable(variable1.name) self.assertEqual(expression.get_value_constant(), 0.0) self.assertEqual(expression.get_value_variable(variable1.name), 0.0)
def testGivenExpressionWithConstantAndVariableWhenMultiplyThenGetValuesReturnsMultipliedTermsValues( self): constant = ConstantBuilder().build() variable = VariableBuilder().build() expression = ExpressionBuilder().term(constant).term(variable).build() multiply_value = 2.0 expression.multiply(multiply_value) constant.multiply(multiply_value) variable.multiply(multiply_value) self.assertEqual(expression.get_value_constant(), constant.value) self.assertEqual(expression.get_value_variable(variable.name), variable.value)
def testStrExpression(self): expression = ExpressionBuilder().constant_fraction( 1, 2).variable_fraction('x', -2, 3).build() self.assertEqual(str(expression), '+1/2 -(2/3)*x') expression = ExpressionBuilder().constant_fraction( 1, 1).variable_fraction('x', -2, 2).build() self.assertEqual(str(expression), '+1 -x') expression = ExpressionBuilder().constant_fraction( 1, 2).variable_fraction('x', -2, 1).build() self.assertEqual(str(expression), '+1/2 -2*x') expression = ExpressionBuilder().constant_fraction( 0, 1).variable_fraction('x', 0, 2).build() self.assertEqual(str(expression), '+0') expression = ExpressionBuilder().variable_fraction( 'x', 0, 2).variable_fraction('x', 0, 2).build() self.assertEqual(str(expression), '+0*x') expression = ExpressionBuilder().variable_fraction( 'x', 0, 2).constant_fraction(0, 2).build() self.assertEqual(str(expression), '+0*x')
def testGivenExpressionWithVariableAndConstantWhenGetValueNameThenVariableValueIsReturned( self): variable = VariableBuilder().name('x').build() expression = ExpressionBuilder().default_constant().term( variable).build() self.assertEqual(expression.get_value_variable('x'), variable.value)
def testGivenExpressionWithTwoConstantsWhenGetValueThenNotSimplifiedIsRaised( self): expression = ExpressionBuilder().default_constant().default_constant( ).build() self.assertRaises(NotSimplified, expression.get_value_constant)
def testGivenExpressionWithTwoVariablesWithSameNameWhenGetValueNameThenNotSimplifiedIsRaised( self): variable = VariableBuilder().name('x').build() expression = ExpressionBuilder().term(variable).term( variable.clon()).build() self.assertRaises(NotSimplified, expression.get_value_variable, 'x')
def testGivenEmptyExpressionWhenGetValueThen0IsReturned(self): expression = ExpressionBuilder().build() self.assertEqual(expression.get_value_constant(), 0)
def testGivenExpressionWithConstantAndVariableWhenGetValueThenConstantValueIsReturned( self): constant = ConstantBuilder().build() expression = ExpressionBuilder().term( constant).default_variable().build() self.assertEqual(expression.get_value_constant(), constant.value)
def testGivenExpressionWithOnlyAVariableAsTermWhenGetValueThen0IsReturned( self): expression = ExpressionBuilder().default_variable().build() self.assertEqual(expression.get_value_constant(), 0)
def testGivenExpressionWithOnlyAConstantAsTermWhenGetValueThenConstantValueIsReturned( self): constant = ConstantBuilder().build() expression = ExpressionBuilder().build() expression.add_term(constant) self.assertEqual(expression.get_value_constant(), constant.value)
def testGivenEmpyExpressionWhenSimplifyThenEmptyExpressionIsObtained(self): expression = ExpressionBuilder().build() expression.simplify_constant() self.assertTrue(expression.empty())
def testGivenExpressionTwoWithVariablesWithDifferentNamesWhenGetValueNameThenCorrectVariableValueIsReturned( self): variable = VariableBuilder().name('x').build() expression = ExpressionBuilder().term( VariableBuilder().name('y').build()).term(variable).build() self.assertEqual(expression.get_value_variable('x'), variable.value)
def testGivenEmpyExpressionWhenSimplifyNameThenEmptyExpressionIsObtained( self): expression = ExpressionBuilder().build() expression.simplify_variable('any_name') self.assertTrue(expression.empty())
def testGivenExpressionWithVariablesWithSpecificNamesWhenGetValueNameWithOtherVariableNameThen0IsReturned( self): expression = ExpressionBuilder().term( VariableBuilder().name('y').build()).term(VariableBuilder().name( 'z').build()).default_constant().build() self.assertEqual(expression.get_value_variable('x'), 0)
def testGivenExpressionWithOneConstantWhenSimplifyThenSameExpressionIsObtained( self): expression = ExpressionBuilder().default_constant().build() expression2 = expression.clon() expression.simplify_constant() self.assertTrue(expression.equal(expression2))