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)
