2325

pending completion

Build # 2325

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #581 from qutech/fix/repetition_pt_integral

Fix RepetitionPT.integral return type

Run Details

2228 of 2979 branches covered (74.79%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

7188 of 8801 relevant lines covered (81.67%)

4.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.02

/qupulse/expressions.py

"""
This module defines the class Expression to represent mathematical expression as well as
corresponding exception classes.
"""
from typing import Any, Dict, Union, Sequence, Callable, TypeVar, Type, Mapping
from numbers import Number
import warnings
import functools
import array
import itertools

import sympy
import numpy

from qupulse.serialization import AnonymousSerializable
from qupulse.utils.sympy import sympify, to_numpy, recursive_substitution, evaluate_lambdified,\
    get_most_simple_representation, get_variables, evaluate_lamdified_exact_rational
from qupulse.utils.types import TimeType

__all__ = ["Expression", "ExpressionVariableMissingException", "ExpressionScalar", "ExpressionVector", "ExpressionLike"]


_ExpressionType = TypeVar('_ExpressionType', bound='Expression')


class _ExpressionMeta(type):
    """Metaclass that forwards calls to Expression(...) to Expression.make(...) to make subclass objects"""
    def __call__(cls: Type[_ExpressionType], *args, **kwargs) -> _ExpressionType:
        if cls is Expression:
            return cls.make(*args, **kwargs)
        else:
            return type.__call__(cls, *args, **kwargs)


class Expression(AnonymousSerializable, metaclass=_ExpressionMeta):
    """Base class for expressions."""
    def __init__(self, *args, **kwargs):
        self._expression_lambda = None

    def _parse_evaluate_numeric_arguments(self, eval_args: Mapping[str, Number]) -> Dict[str, Number]:
        try:
            return {v: eval_args[v] for v in self.variables}
        except KeyError as key_error:
            if type(key_error).__module__.startswith('qupulse'):
                # we forward qupulse errors, I down like this
                raise
            else:
                raise ExpressionVariableMissingException(key_error.args[0], self) from key_error

    def _parse_evaluate_numeric_result(self,
                                       result: Union[Number, numpy.ndarray],
                                       call_arguments: Any) -> Union[Number, numpy.ndarray]:
        allowed_types = (float, numpy.number, int, complex, bool, numpy.bool_, TimeType)
        if isinstance(result, tuple):
            result = numpy.array(result)
        if isinstance(result, numpy.ndarray):
            if issubclass(result.dtype.type, allowed_types):
                return result
            else:
                obj_types = set(map(type, result.flat))
                if obj_types == {sympy.Float} or obj_types == {sympy.Float, sympy.Integer}:
                    return result.astype(float)
                elif obj_types == {sympy.Integer}:
                    return result.astype(numpy.int64)
                else:
                    raise NonNumericEvaluation(self, result, call_arguments)
        elif isinstance(result, allowed_types):
            return result
        elif isinstance(result, sympy.Float):
            return float(result)
        elif isinstance(result, sympy.Integer):
            return int(result)
        else:
            raise NonNumericEvaluation(self, result, call_arguments)

    def evaluate_in_scope(self, scope: Mapping) -> Union[Number, numpy.ndarray]:
        """Evaluate the expression by taking the variables from the given scope (typically of type Scope but it can be
        any mapping.)
        Args:
            scope:

        Returns:

        """
        parsed_kwargs = self._parse_evaluate_numeric_arguments(scope)

        result, self._expression_lambda = evaluate_lambdified(self.underlying_expression, self.variables,
                                                              parsed_kwargs, lambdified=self._expression_lambda)

        return self._parse_evaluate_numeric_result(result, scope)

    def evaluate_numeric(self, **kwargs) -> Union[Number, numpy.ndarray]:
        parsed_kwargs = self._parse_evaluate_numeric_arguments(kwargs)

        result, self._expression_lambda = evaluate_lambdified(self.underlying_expression, self.variables,
                                                              parsed_kwargs, lambdified=self._expression_lambda)

        return self._parse_evaluate_numeric_result(result, kwargs)

    def __float__(self):
        if self.variables:
            return NotImplemented
        else:
            e = self.evaluate_numeric()
            return float(e)

    def evaluate_symbolic(self, substitutions: Mapping[Any, Any]) -> 'Expression':
        if len(substitutions)==0:
            return self
        return Expression.make(recursive_substitution(sympify(self.underlying_expression), substitutions))

    @property
    def variables(self) -> Sequence[str]:
        """ Get all free variables in the expression.

        Returns:
            A collection of all free variables occurring in the expression.
        """
        raise NotImplementedError()

    @classmethod
    def make(cls: Type[_ExpressionType],
             expression_or_dict,
             numpy_evaluation=None) -> Union['ExpressionScalar', 'ExpressionVector', _ExpressionType]:
        """Backward compatible expression generation"""
        if numpy_evaluation is not None:
            warnings.warn('numpy_evaluation keyword argument is deprecated and ignored.')

        if isinstance(expression_or_dict, dict):
            expression = expression_or_dict['expression']
        elif isinstance(expression_or_dict, cls):
            return expression_or_dict
        else:
            expression = expression_or_dict

        if cls is Expression:
            if isinstance(expression, (list, tuple, numpy.ndarray, sympy.NDimArray, array.array)):
                return ExpressionVector(expression)
            else:
                return ExpressionScalar(expression)
        else:
            return cls(expression)

    @property
    def underlying_expression(self) -> Union[sympy.Expr, numpy.ndarray]:
        raise NotImplementedError()


class ExpressionVector(Expression):
    """N-dimensional expression.
    TODO: write doc!
    TODO: write tests!
    """
    sympify_vector = numpy.vectorize(sympify)

    def __init__(self, expression_vector: Sequence):
        super().__init__()
        if isinstance(expression_vector, sympy.NDimArray):
            expression_vector = to_numpy(expression_vector)
        self._expression_vector = self.sympify_vector(expression_vector)
        variables = set(itertools.chain.from_iterable(map(get_variables, self._expression_vector.flat)))
        self._variables = tuple(variables)

    @property
    def expression_lambda(self) -> Callable:
        if self._expression_lambda is None:
            expression_lambda = sympy.lambdify(self.variables, self.underlying_expression,
                                                     [{'ceiling': ceiling}, 'numpy'])

            @functools.wraps(expression_lambda)
            def expression_wrapper(*args, **kwargs):
                result = expression_lambda(*args, **kwargs)
                if isinstance(result, sympy.NDimArray):
                    return numpy.array(result.tolist())
                elif isinstance(result, list):
                    return numpy.array(result).reshape(self.underlying_expression.shape)
                else:
                    return result.reshape(self.underlying_expression.shape)
            self._expression_lambda = expression_wrapper
        return self._expression_lambda

    @property
    def variables(self) -> Sequence[str]:
        return self._variables

    def evaluate_numeric(self, **kwargs) -> Union[numpy.ndarray, Number]:
        parsed_kwargs = self._parse_evaluate_numeric_arguments(kwargs)

        result, self._expression_lambda = evaluate_lambdified(self.underlying_expression, self.variables,
                                                              parsed_kwargs, lambdified=self._expression_lambda)

        if isinstance(result, (list, tuple)):
            result = numpy.array(result)

        return self._parse_evaluate_numeric_result(numpy.array(result), kwargs)

    def get_serialization_data(self) -> Sequence[str]:
        def nested_get_most_simple_representation(list_or_expression):
            if isinstance(list_or_expression, list):
                return [nested_get_most_simple_representation(entry)
                        for entry in list_or_expression]
            else:
                return get_most_simple_representation(list_or_expression)
        return nested_get_most_simple_representation(self._expression_vector.tolist())

    def __str__(self):
        return str(self.get_serialization_data())

    def __repr__(self):
        return 'ExpressionVector({})'.format(repr(self.get_serialization_data()))

    def _sympy_(self):
        return sympy.NDimArray(self._expression_vector)

    def __eq__(self, other):
        if not isinstance(other, Expression):
            other = Expression.make(other)
        if isinstance(other, ExpressionScalar):
            return self._expression_vector.size == 1 and self._expression_vector[0] == other.underlying_expression
        if isinstance(other, ExpressionVector) and self._expression_vector.shape != other._expression_vector.shape:
            return False
        return numpy.all(self._expression_vector == other.underlying_expression)

    def __getitem__(self, item) -> Expression:
        return self._expression_vector[item]

    @property
    def underlying_expression(self) -> numpy.ndarray:
        return self._expression_vector


class ExpressionScalar(Expression):
    """A scalar mathematical expression instantiated from a string representation.
        TODO: update doc!
        TODO: write tests!
        """

    def __init__(self, ex: Union[str, Number, sympy.Expr]) -> None:
        """Create an Expression object.

        Receives the mathematical expression which shall be represented by the object as a string
        which will be parsed using py_expression_eval. For available operators, functions and
        constants see SymPy documentation

        Args:
            ex (string): The mathematical expression represented as a string
        """
        super().__init__()

        if isinstance(ex, sympy.Expr):
            self._original_expression = None
            self._sympified_expression = ex
        else:
            self._original_expression = ex
            self._sympified_expression = sympify(ex)

        self._variables = get_variables(self._sympified_expression)
        self._exact_rational_lambdified = None

    @property
    def underlying_expression(self) -> sympy.Expr:
        return self._sympified_expression

    def __str__(self) -> str:
        return str(self._sympified_expression)

    def __repr__(self) -> str:
        return 'Expression({})'.format(repr(self._original_expression))

    def __format__(self, format_spec):
        if format_spec == '':
            return str(self)
        return format(float(self), format_spec)
    
    @property
    def variables(self) -> Sequence[str]:
        return self._variables

    @classmethod
    def _sympify(cls, other: Union['ExpressionScalar', Number, sympy.Expr]) -> sympy.Expr:
        return other._sympified_expression if isinstance(other, cls) else sympify(other)

    def __lt__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> Union[bool, None]:
        result = self._sympified_expression < self._sympify(other)
        return None if isinstance(result, sympy.Rel) else bool(result)

    def __gt__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> Union[bool, None]:
        result = self._sympified_expression > self._sympify(other)
        return None if isinstance(result, sympy.Rel) else bool(result)

    def __ge__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> Union[bool, None]:
        result = self._sympified_expression >= self._sympify(other)
        return None if isinstance(result, sympy.Rel) else bool(result)

    def __le__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> Union[bool, None]:
        result = self._sympified_expression <= self._sympify(other)
        return None if isinstance(result, sympy.Rel) else bool(result)

    def __eq__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> bool:
        """Enable comparisons with Numbers"""
        # sympy's __eq__ checks for structural equality to be consistent regarding __hash__ so we do that too
        # see https://github.com/sympy/sympy/issues/18054#issuecomment-566198899
        return self._sympified_expression == self._sympify(other)

    def __hash__(self) -> int:
        return hash(self._sympified_expression)

    def __add__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':
        return self.make(self._sympified_expression.__add__(self._sympify(other)))

    def __radd__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':
        return self.make(self._sympify(other).__radd__(self._sympified_expression))

    def __sub__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':
        return self.make(self._sympified_expression.__sub__(self._sympify(other)))

    def __rsub__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':
        return self.make(self._sympified_expression.__rsub__(self._sympify(other)))

    def __mul__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':
        return self.make(self._sympified_expression.__mul__(self._sympify(other)))

    def __rmul__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':
        return self.make(self._sympified_expression.__rmul__(self._sympify(other)))

    def __truediv__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':
        return self.make(self._sympified_expression.__truediv__(self._sympify(other)))

    def __rtruediv__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':
        return self.make(self._sympified_expression.__rtruediv__(self._sympify(other)))

    def __neg__(self) -> 'ExpressionScalar':
        return self.make(self._sympified_expression.__neg__())

    def __pos__(self):
        return self.make(self._sympified_expression.__pos__())

    def _sympy_(self):
        return self._sympified_expression

    @property
    def original_expression(self) -> Union[str, Number]:
        if self._original_expression is None:
            return str(self._sympified_expression)
        else:
            return self._original_expression

    @property
    def sympified_expression(self) -> sympy.Expr:
        return self._sympified_expression

    def get_serialization_data(self) -> Union[str, float, int]:
        serialized = get_most_simple_representation(self._sympified_expression)
        if isinstance(serialized, str):
            return self.original_expression
        else:
            return serialized

    def is_nan(self) -> bool:
        return sympy.sympify('nan') == self._sympified_expression

    def _parse_evaluate_numeric_result(self,
                                       result: Union[Number, numpy.ndarray],
                                       call_arguments: Any) -> Number:
        """Overwrite super class method because we do not want to return a scalar numpy.ndarray"""
        parsed = super()._parse_evaluate_numeric_result(result, call_arguments)
        if isinstance(parsed, numpy.ndarray):
            return parsed[()]
        else:
            return parsed

    def evaluate_with_exact_rationals(self, scope: Mapping) -> Number:
        parsed_kwargs = self._parse_evaluate_numeric_arguments(scope)
        result, self._exact_rational_lambdified = evaluate_lamdified_exact_rational(self.sympified_expression,
                                                                                    self.variables,
                                                                                    parsed_kwargs,
                                                                                    self._exact_rational_lambdified)
        return self._parse_evaluate_numeric_result(result, scope)


class ExpressionVariableMissingException(Exception):
    """An exception indicating that a variable value was not provided during expression evaluation.

    See also:
         qupulse.expressions.Expression
    """

    def __init__(self, variable: str, expression: Expression) -> None:
        super().__init__()
        self.variable = variable
        self.expression = expression

    def __str__(self) -> str:
        return "Could not evaluate <{}>: A value for variable <{}> is missing!".format(
            str(self.expression), self.variable)


class NonNumericEvaluation(Exception):
    """An exception that is raised if the result of evaluate_numeric is not a number.

    See also:
        qupulse.expressions.Expression.evaluate_numeric
    """

    def __init__(self, expression: Expression, non_numeric_result: Any, call_arguments: Dict):
        self.expression = expression
        self.non_numeric_result = non_numeric_result
        self.call_arguments = call_arguments

    def __str__(self) -> str:
        if isinstance(self.non_numeric_result, numpy.ndarray):
            dtype = self.non_numeric_result.dtype

            if dtype == numpy.dtype('O'):
                dtypes = set(map(type, self.non_numeric_result.flat))
                "The result of evaluate_numeric is an array with the types {} " \
                "which is not purely numeric".format(dtypes)
        else:
            dtype = type(self.non_numeric_result)
        return "The result of evaluate_numeric is of type {} " \
               "which is not a number".format(dtype)


ExpressionLike = TypeVar('ExpressionLike', str, Number, sympy.Expr, ExpressionScalar)

1	"""
2	This module defines the class Expression to represent mathematical expression as well as
3	corresponding exception classes.
4	"""
5	from typing import Any, Dict, Union, Sequence, Callable, TypeVar, Type, Mapping	6✔
6	from numbers import Number	6✔
7	import warnings	6✔
8	import functools	6✔
9	import array	6✔
10	import itertools	6✔
11
12	import sympy	6✔
13	import numpy	6✔
14
15	from qupulse.serialization import AnonymousSerializable	6✔
16	from qupulse.utils.sympy import sympify, to_numpy, recursive_substitution, evaluate_lambdified,\	6✔
17	get_most_simple_representation, get_variables, evaluate_lamdified_exact_rational
18	from qupulse.utils.types import TimeType	6✔
19
20	__all__ = ["Expression", "ExpressionVariableMissingException", "ExpressionScalar", "ExpressionVector", "ExpressionLike"]	6✔
21
22
23	_ExpressionType = TypeVar('_ExpressionType', bound='Expression')	6✔
24
25
26	class _ExpressionMeta(type):	6✔
27	"""Metaclass that forwards calls to Expression(...) to Expression.make(...) to make subclass objects"""
28	def __call__(cls: Type[_ExpressionType], args, *kwargs) -> _ExpressionType:	6✔
29	if cls is Expression:	6✔
30	return cls.make(args, *kwargs)	6✔
31	else:
32	return type.__call__(cls, args, *kwargs)	6✔
33
34
35	class Expression(AnonymousSerializable, metaclass=_ExpressionMeta):	6✔
36	"""Base class for expressions."""
37	def __init__(self, args, *kwargs):	6✔
38	self._expression_lambda = None	6✔
39
40	def _parse_evaluate_numeric_arguments(self, eval_args: Mapping[str, Number]) -> Dict[str, Number]:	6✔
41	try:	6✔
42	return {v: eval_args[v] for v in self.variables}	6✔
43	except KeyError as key_error:	6✔
44	if type(key_error).__module__.startswith('qupulse'):	6✔
45	# we forward qupulse errors, I down like this
46	raise	6✔
47	else:
48	raise ExpressionVariableMissingException(key_error.args[0], self) from key_error	6✔
49
50	def _parse_evaluate_numeric_result(self,	6✔
51	result: Union[Number, numpy.ndarray],
52	call_arguments: Any) -> Union[Number, numpy.ndarray]:
53	allowed_types = (float, numpy.number, int, complex, bool, numpy.bool_, TimeType)	6✔
54	if isinstance(result, tuple):	6!
55	result = numpy.array(result)	×
56	if isinstance(result, numpy.ndarray):	6✔
57	if issubclass(result.dtype.type, allowed_types):	6✔
58	return result	6✔
59	else:
60	obj_types = set(map(type, result.flat))	6✔
61	if obj_types == {sympy.Float} or obj_types == {sympy.Float, sympy.Integer}:	6!
62	return result.astype(float)	×
63	elif obj_types == {sympy.Integer}:	6!
64	return result.astype(numpy.int64)	×
65	else:
66	raise NonNumericEvaluation(self, result, call_arguments)	6✔
67	elif isinstance(result, allowed_types):	6✔
68	return result	6✔
69	elif isinstance(result, sympy.Float):	6!
70	return float(result)	×
71	elif isinstance(result, sympy.Integer):	6!
72	return int(result)	×
73	else:
74	raise NonNumericEvaluation(self, result, call_arguments)	6✔
75
76	def evaluate_in_scope(self, scope: Mapping) -> Union[Number, numpy.ndarray]:	6✔
77	"""Evaluate the expression by taking the variables from the given scope (typically of type Scope but it can be
78	any mapping.)
79	Args:
80	scope:
81
82	Returns:
83
84	"""
85	parsed_kwargs = self._parse_evaluate_numeric_arguments(scope)	6✔
86
87	result, self._expression_lambda = evaluate_lambdified(self.underlying_expression, self.variables,	6✔
88	parsed_kwargs, lambdified=self._expression_lambda)
89
90	return self._parse_evaluate_numeric_result(result, scope)	6✔
91
92	def evaluate_numeric(self, **kwargs) -> Union[Number, numpy.ndarray]:	6✔
93	parsed_kwargs = self._parse_evaluate_numeric_arguments(kwargs)	6✔
94
95	result, self._expression_lambda = evaluate_lambdified(self.underlying_expression, self.variables,	6✔
96	parsed_kwargs, lambdified=self._expression_lambda)
97
98	return self._parse_evaluate_numeric_result(result, kwargs)	6✔
99
100	def __float__(self):	6✔
101	if self.variables:	6✔
102	return NotImplemented	6✔
103	else:
104	e = self.evaluate_numeric()	6✔
105	return float(e)	6✔
106
107	def evaluate_symbolic(self, substitutions: Mapping[Any, Any]) -> 'Expression':	6✔
108	if len(substitutions)==0:	6!
109	return self	×
110	return Expression.make(recursive_substitution(sympify(self.underlying_expression), substitutions))	6✔
111
112	@property	6✔
113	def variables(self) -> Sequence[str]:	6✔
114	""" Get all free variables in the expression.
115
116	Returns:
117	A collection of all free variables occurring in the expression.
118	"""
119	raise NotImplementedError()	×
120
121	@classmethod	6✔
122	def make(cls: Type[_ExpressionType],	6✔
123	expression_or_dict,
124	numpy_evaluation=None) -> Union['ExpressionScalar', 'ExpressionVector', _ExpressionType]:
125	"""Backward compatible expression generation"""
126	if numpy_evaluation is not None:	6!
127	warnings.warn('numpy_evaluation keyword argument is deprecated and ignored.')	×
128
129	if isinstance(expression_or_dict, dict):	6!
130	expression = expression_or_dict['expression']	×
131	elif isinstance(expression_or_dict, cls):	6✔
132	return expression_or_dict	6✔
133	else:
134	expression = expression_or_dict	6✔
135
136	if cls is Expression:	6✔
137	if isinstance(expression, (list, tuple, numpy.ndarray, sympy.NDimArray, array.array)):	6✔
138	return ExpressionVector(expression)	6✔
139	else:
140	return ExpressionScalar(expression)	6✔
141	else:
142	return cls(expression)	6✔
143
144	@property	6✔
145	def underlying_expression(self) -> Union[sympy.Expr, numpy.ndarray]:	6✔
146	raise NotImplementedError()	×
147
148
149	class ExpressionVector(Expression):	6✔
150	"""N-dimensional expression.
151	TODO: write doc!
152	TODO: write tests!
153	"""
154	sympify_vector = numpy.vectorize(sympify)	6✔
155
156	def __init__(self, expression_vector: Sequence):	6✔
157	super().__init__()	6✔
158	if isinstance(expression_vector, sympy.NDimArray):	6✔
159	expression_vector = to_numpy(expression_vector)	6✔
160	self._expression_vector = self.sympify_vector(expression_vector)	6✔
161	variables = set(itertools.chain.from_iterable(map(get_variables, self._expression_vector.flat)))	6✔
162	self._variables = tuple(variables)	6✔
163
164	@property	6✔
165	def expression_lambda(self) -> Callable:	6✔
166	if self._expression_lambda is None:	×
167	expression_lambda = sympy.lambdify(self.variables, self.underlying_expression,	×
168	[{'ceiling': ceiling}, 'numpy'])
169
170	@functools.wraps(expression_lambda)	×
171	def expression_wrapper(args, *kwargs):
172	result = expression_lambda(args, *kwargs)	×
173	if isinstance(result, sympy.NDimArray):	×
174	return numpy.array(result.tolist())	×
175	elif isinstance(result, list):	×
176	return numpy.array(result).reshape(self.underlying_expression.shape)	×
177	else:
178	return result.reshape(self.underlying_expression.shape)	×
179	self._expression_lambda = expression_wrapper	×
180	return self._expression_lambda	×
181
182	@property	6✔
183	def variables(self) -> Sequence[str]:	6✔
184	return self._variables	6✔
185
186	def evaluate_numeric(self, **kwargs) -> Union[numpy.ndarray, Number]:	6✔
187	parsed_kwargs = self._parse_evaluate_numeric_arguments(kwargs)	6✔
188
189	result, self._expression_lambda = evaluate_lambdified(self.underlying_expression, self.variables,	6✔
190	parsed_kwargs, lambdified=self._expression_lambda)
191
192	if isinstance(result, (list, tuple)):	6!
193	result = numpy.array(result)	6✔
194
195	return self._parse_evaluate_numeric_result(numpy.array(result), kwargs)	6✔
196
197	def get_serialization_data(self) -> Sequence[str]:	6✔
198	def nested_get_most_simple_representation(list_or_expression):	6✔
199	if isinstance(list_or_expression, list):	6✔
200	return [nested_get_most_simple_representation(entry)	6✔
201	for entry in list_or_expression]
202	else:
203	return get_most_simple_representation(list_or_expression)	6✔
204	return nested_get_most_simple_representation(self._expression_vector.tolist())	6✔
205
206	def __str__(self):	6✔
207	return str(self.get_serialization_data())	×
208
209	def __repr__(self):	6✔
210	return 'ExpressionVector({})'.format(repr(self.get_serialization_data()))	×
211
212	def _sympy_(self):	6✔
213	return sympy.NDimArray(self._expression_vector)	×
214
215	def __eq__(self, other):	6✔
216	if not isinstance(other, Expression):	6✔
217	other = Expression.make(other)	6✔
218	if isinstance(other, ExpressionScalar):	6✔
219	return self._expression_vector.size == 1 and self._expression_vector[0] == other.underlying_expression	6✔
220	if isinstance(other, ExpressionVector) and self._expression_vector.shape != other._expression_vector.shape:	6✔
221	return False	6✔
222	return numpy.all(self._expression_vector == other.underlying_expression)	6✔
223
224	def __getitem__(self, item) -> Expression:	6✔
225	return self._expression_vector[item]	×
226
227	@property	6✔
228	def underlying_expression(self) -> numpy.ndarray:	6✔
229	return self._expression_vector	6✔
230
231
232	class ExpressionScalar(Expression):	6✔
233	"""A scalar mathematical expression instantiated from a string representation.
234	TODO: update doc!
235	TODO: write tests!
236	"""
237
238	def __init__(self, ex: Union[str, Number, sympy.Expr]) -> None:	6✔
239	"""Create an Expression object.
240
241	Receives the mathematical expression which shall be represented by the object as a string
242	which will be parsed using py_expression_eval. For available operators, functions and
243	constants see SymPy documentation
244
245	Args:
246	ex (string): The mathematical expression represented as a string
247	"""
248	super().__init__()	6✔
249
250	if isinstance(ex, sympy.Expr):	6✔
251	self._original_expression = None	6✔
252	self._sympified_expression = ex	6✔
253	else:
254	self._original_expression = ex	6✔
255	self._sympified_expression = sympify(ex)	6✔
256
257	self._variables = get_variables(self._sympified_expression)	6✔
258	self._exact_rational_lambdified = None	6✔
259
260	@property	6✔
261	def underlying_expression(self) -> sympy.Expr:	6✔
262	return self._sympified_expression	6✔
263
264	def __str__(self) -> str:	6✔
265	return str(self._sympified_expression)	6✔
266
267	def __repr__(self) -> str:	6✔
268	return 'Expression({})'.format(repr(self._original_expression))	6✔
269
270	def __format__(self, format_spec):	6✔
271	if format_spec == '':	6✔
272	return str(self)	6✔
273	return format(float(self), format_spec)	6✔
274
275	@property	6✔
276	def variables(self) -> Sequence[str]:	6✔
277	return self._variables	6✔
278
279	@classmethod	6✔
280	def _sympify(cls, other: Union['ExpressionScalar', Number, sympy.Expr]) -> sympy.Expr:	6✔
281	return other._sympified_expression if isinstance(other, cls) else sympify(other)	6✔
282
283	def __lt__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> Union[bool, None]:	6✔
284	result = self._sympified_expression < self._sympify(other)	6✔
285	return None if isinstance(result, sympy.Rel) else bool(result)	6✔
286
287	def __gt__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> Union[bool, None]:	6✔
288	result = self._sympified_expression > self._sympify(other)	6✔
289	return None if isinstance(result, sympy.Rel) else bool(result)	6✔
290
291	def __ge__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> Union[bool, None]:	6✔
292	result = self._sympified_expression >= self._sympify(other)	6✔
293	return None if isinstance(result, sympy.Rel) else bool(result)	6✔
294
295	def __le__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> Union[bool, None]:	6✔
296	result = self._sympified_expression <= self._sympify(other)	6✔
297	return None if isinstance(result, sympy.Rel) else bool(result)	6✔
298
299	def __eq__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> bool:	6✔
300	"""Enable comparisons with Numbers"""
301	# sympy's __eq__ checks for structural equality to be consistent regarding __hash__ so we do that too
302	# see https://github.com/sympy/sympy/issues/18054#issuecomment-566198899
303	return self._sympified_expression == self._sympify(other)	6✔
304
305	def __hash__(self) -> int:	6✔
306	return hash(self._sympified_expression)	6✔
307
308	def __add__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':	6✔
309	return self.make(self._sympified_expression.__add__(self._sympify(other)))	6✔
310
311	def __radd__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':	6✔
312	return self.make(self._sympify(other).__radd__(self._sympified_expression))	6✔
313
314	def __sub__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':	6✔
315	return self.make(self._sympified_expression.__sub__(self._sympify(other)))	6✔
316
317	def __rsub__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':	6✔
318	return self.make(self._sympified_expression.__rsub__(self._sympify(other)))	6✔
319
320	def __mul__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':	6✔
321	return self.make(self._sympified_expression.__mul__(self._sympify(other)))	6✔
322
323	def __rmul__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':	6✔
324	return self.make(self._sympified_expression.__rmul__(self._sympify(other)))	6✔
325
326	def __truediv__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':	6✔
327	return self.make(self._sympified_expression.__truediv__(self._sympify(other)))	6✔
328
329	def __rtruediv__(self, other: Union['ExpressionScalar', Number, sympy.Expr]) -> 'ExpressionScalar':	6✔
330	return self.make(self._sympified_expression.__rtruediv__(self._sympify(other)))	6✔
331
332	def __neg__(self) -> 'ExpressionScalar':	6✔
333	return self.make(self._sympified_expression.__neg__())	6✔
334
335	def __pos__(self):	6✔
336	return self.make(self._sympified_expression.__pos__())	6✔
337
338	def _sympy_(self):	6✔
339	return self._sympified_expression	6✔
340
341	@property	6✔
342	def original_expression(self) -> Union[str, Number]:	6✔
343	if self._original_expression is None:	6!
344	return str(self._sympified_expression)	×
345	else:
346	return self._original_expression	6✔
347
348	@property	6✔
349	def sympified_expression(self) -> sympy.Expr:	6✔
350	return self._sympified_expression	6✔
351
352	def get_serialization_data(self) -> Union[str, float, int]:	6✔
353	serialized = get_most_simple_representation(self._sympified_expression)	6✔
354	if isinstance(serialized, str):	6✔
355	return self.original_expression	6✔
356	else:
357	return serialized	6✔
358
359	def is_nan(self) -> bool:	6✔
360	return sympy.sympify('nan') == self._sympified_expression	6✔
361
362	def _parse_evaluate_numeric_result(self,	6✔
363	result: Union[Number, numpy.ndarray],
364	call_arguments: Any) -> Number:
365	"""Overwrite super class method because we do not want to return a scalar numpy.ndarray"""
366	parsed = super()._parse_evaluate_numeric_result(result, call_arguments)	6✔
367	if isinstance(parsed, numpy.ndarray):	6✔
368	return parsed[()]	6✔
369	else:
370	return parsed	6✔
371
372	def evaluate_with_exact_rationals(self, scope: Mapping) -> Number:	6✔
373	parsed_kwargs = self._parse_evaluate_numeric_arguments(scope)	6✔
374	result, self._exact_rational_lambdified = evaluate_lamdified_exact_rational(self.sympified_expression,	6✔
375	self.variables,
376	parsed_kwargs,
377	self._exact_rational_lambdified)
378	return self._parse_evaluate_numeric_result(result, scope)	6✔
379
380
381	class ExpressionVariableMissingException(Exception):	6✔
382	"""An exception indicating that a variable value was not provided during expression evaluation.
383
384	See also:
385	qupulse.expressions.Expression
386	"""
387
388	def __init__(self, variable: str, expression: Expression) -> None:	6✔
389	super().__init__()	6✔
390	self.variable = variable	6✔
391	self.expression = expression	6✔
392
393	def __str__(self) -> str:	6✔
394	return "Could not evaluate <{}>: A value for variable <{}> is missing!".format(	6✔
395	str(self.expression), self.variable)
396
397
398	class NonNumericEvaluation(Exception):	6✔
399	"""An exception that is raised if the result of evaluate_numeric is not a number.
400
401	See also:
402	qupulse.expressions.Expression.evaluate_numeric
403	"""
404
405	def __init__(self, expression: Expression, non_numeric_result: Any, call_arguments: Dict):	6✔
406	self.expression = expression	6✔
407	self.non_numeric_result = non_numeric_result	6✔
408	self.call_arguments = call_arguments	6✔
409
410	def __str__(self) -> str:	6✔
411	if isinstance(self.non_numeric_result, numpy.ndarray):	6✔
412	dtype = self.non_numeric_result.dtype	6✔
413
414	if dtype == numpy.dtype('O'):	6!
415	dtypes = set(map(type, self.non_numeric_result.flat))	×
416	"The result of evaluate_numeric is an array with the types {} " \	×
417	"which is not purely numeric".format(dtypes)
418	else:
419	dtype = type(self.non_numeric_result)	6✔
420	return "The result of evaluate_numeric is of type {} " \	6✔
421	"which is not a number".format(dtype)
422
423
424	ExpressionLike = TypeVar('ExpressionLike', str, Number, sympy.Expr, ExpressionScalar)	6✔

qutech / qupulse / 2325

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous