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_special_function_numeric_evaluation(self):
expr = Expression('erfc(t)')
data = [-1., 0., 1.]
expected = np.array([1.84270079, 1., 0.15729921])
result = expr.evaluate_numeric(t=data)
np.testing.assert_allclose(expected, result)
def test_expression_value(self) -> None:
expression_str = "exp(4)*sin(pi/2)"
expression_obj = Expression(expression_str)
expression_val = expression_obj.evaluate_numeric()
param = ConstantParameter(expression_str)
self.assertEqual(expression_val, param.get_value())
param = ConstantParameter(expression_obj)
self.assertEqual(expression_val, param.get_value())
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 __repr__(self):
return 'ParameterConstraint(%s)' % repr(str(self))
def get_serialization_data(self) -> str:
return str(self)