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 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 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 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 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 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 __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 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 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 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 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 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 testGivenExpressionWithTwoVariablesWithSameNameWhenGetValueNameThenNotSimplifiedIsRaised(
self):
variable = VariableBuilder().name('x').build()
expression = ExpressionBuilder().term(variable).term(
variable.clon()).build()
self.assertRaises(NotSimplified, expression.get_value_variable, 'x')
def testGivenExpressionWithTwoConstantsWhenGetValueThenNotSimplifiedIsRaised(
self):
expression = ExpressionBuilder().default_constant().default_constant(
).build()
self.assertRaises(NotSimplified, expression.get_value_constant)
def testGivenExpressionWithConstantAndVariableWhenGetValueThenConstantValueIsReturned(
self):
constant = ConstantBuilder().build()
expression = ExpressionBuilder().term(
constant).default_variable().build()
self.assertEqual(expression.get_value_constant(), constant.value)
def testGivenEmptyExpressionWhenGetValueThen0IsReturned(self):
expression = ExpressionBuilder().build()
self.assertEqual(expression.get_value_constant(), 0)
def testGivenExpressionWithOnlyAVariableAsTermWhenGetValueThen0IsReturned(
self):
expression = ExpressionBuilder().default_variable().build()
self.assertEqual(expression.get_value_constant(), 0)
def testGivenExpressionWithOneConstantWhenSimplifyThenSameExpressionIsObtained(
self):
expression = ExpressionBuilder().default_constant().build()
expression2 = expression.clon()
expression.simplify_constant()
self.assertTrue(expression.equal(expression2))
def testGivenEmpyExpressionWhenSimplifyNameThenEmptyExpressionIsObtained(
self):
expression = ExpressionBuilder().build()
expression.simplify_variable('any_name')
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 testGivenExpressionWithOnlyAConstantAsTermWhenGetValueThenConstantValueIsReturned(
self):
constant = ConstantBuilder().build()
expression = ExpressionBuilder().build()
expression.add_term(constant)
self.assertEqual(expression.get_value_constant(), constant.value)
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 testGivenEmpyExpressionWhenSimplifyThenEmptyExpressionIsObtained(self):
expression = ExpressionBuilder().build()
expression.simplify_constant()
self.assertTrue(expression.empty())
