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)