def test_evaluate_numeric(self) -> None: e = Expression('a * b + c') params = {'a': 2, 'b': 1.5, 'c': -7} self.assertEqual(2 * 1.5 - 7, e.evaluate_numeric(**params)) with self.assertRaises(NonNumericEvaluation): params['a'] = sympify('h') e.evaluate_numeric(**params)
def test_evaluate_numeric_without_numpy(self): e = Expression('a * b + c') params = {'a': 2, 'b': 1.5, 'c': -7} self.assertEqual(2 * 1.5 - 7, e.evaluate_numeric(**params)) params = {'a': 2j, 'b': 1.5, 'c': -7} self.assertEqual(2j * 1.5 - 7, e.evaluate_numeric(**params)) params = {'a': 2, 'b': 6, 'c': -7} self.assertEqual(2 * 6 - 7, e.evaluate_numeric(**params)) params = {'a': 2, 'b': sympify('k'), 'c': -7} with self.assertRaises(NonNumericEvaluation): e.evaluate_numeric(**params)
def test_evaluate_numpy(self): e = Expression('a * b + c') params = { 'a': 2 * np.ones(4), 'b': 1.5 * np.ones(4), 'c': -7 * np.ones(4) } np.testing.assert_equal((2 * 1.5 - 7) * np.ones(4), e.evaluate_numeric(**params))
class ParameterConstraint(AnonymousSerializable): """A parameter constraint like 't_2 < 2.7' that can be used to set bounds to parameters.""" def __init__(self, relation: Union[str, sympy.Expr]): super().__init__() if isinstance(relation, str) and '==' in relation: # The '==' operator is interpreted by sympy as exactly, however we need a symbolical evaluation self._expression = sympy.Eq(*sympy.sympify(relation.split('=='))) else: self._expression = sympy.sympify(relation) if not isinstance(self._expression, sympy.boolalg.Boolean): raise ValueError('Constraint is not boolean') self._expression = Expression(self._expression) @property def affected_parameters(self) -> Set[str]: return set(self._expression.variables) def is_fulfilled(self, parameter: Dict[str, Any]) -> bool: if not self.affected_parameters <= set(parameter.keys()): raise ParameterNotProvidedException( (self.affected_parameters - set(parameter.keys())).pop()) return numpy.all(self._expression.evaluate_numeric(**parameter)) @property def sympified_expression(self) -> sympy.Expr: return self._expression.sympified_expression def __eq__(self, other: 'ParameterConstraint') -> bool: return self._expression.underlying_expression == other._expression.underlying_expression def __str__(self) -> str: if isinstance(self._expression.sympified_expression, sympy.Eq): return '{}=={}'.format(self._expression.sympified_expression.lhs, self._expression.sympified_expression.rhs) else: return str(self._expression.sympified_expression) def get_serialization_data(self) -> str: return str(self)
def test_evaluate_variable_missing(self) -> None: e = Expression('a * b + c') params = {'b': 1.5} with self.assertRaises(ExpressionVariableMissingException): e.evaluate_numeric(**params)