def __init__(self, *args, **kwargs):
"""Positional and keyword arguments cannot be mixed.
Args:
*args: Interpreted as ``(start, )`` or ``(start, stop[, step])``
**kwargs: Expected to contain ``start``, ``stop`` and ``step``
Raises:
TypeError: If positional and keyword arguments are mixed
KeyError: If keyword arguments but one of ``start``, ``stop`` or ``step`` is missing
"""
if args and kwargs:
raise TypeError(
'ParametrizedRange only takes either positional or keyword arguments'
)
elif kwargs:
start = kwargs['start']
stop = kwargs['stop']
step = kwargs['step']
elif len(args) in (1, 2, 3):
if len(args) == 3:
start, stop, step = args
elif len(args) == 2:
(start, stop), step = args, 1
elif len(args) == 1:
start, (stop, ), step = 0, args, 1
else:
raise TypeError(
'ParametrizedRange expected 1 to 3 arguments, got {}'.format(
len(args)))
self.start = ExpressionScalar.make(start)
self.stop = ExpressionScalar.make(stop)
self.step = ExpressionScalar.make(step)
def test_make(self):
self.assertTrue(Expression.make('a') == 'a')
self.assertTrue(Expression.make('a + b') == 'a + b')
self.assertTrue(Expression.make(9) == 9)
self.assertIsInstance(Expression.make([1, 'a']), ExpressionVector)
self.assertIsInstance(ExpressionScalar.make('a'), ExpressionScalar)
self.assertIsInstance(ExpressionVector.make(['a']), ExpressionVector)
def __new__(cls, t: ValueInInit, v: ValueInInit, interp: Optional[Union[str, InterpolationStrategy]]='default'):
if interp in TablePulseTemplate.interpolation_strategies:
interp = TablePulseTemplate.interpolation_strategies[interp]
if interp is not None and not isinstance(interp, InterpolationStrategy):
raise KeyError(interp, 'is not a valid interpolation strategy')
return super().__new__(cls, ExpressionScalar.make(t),
Expression.make(v),
interp)
def __init__(self,
expression: Union[str, ExpressionScalar],
duration_expression: Union[str, ExpressionScalar],
channel: ChannelID = 'default',
identifier: Optional[str] = None,
*,
measurements: Optional[List[MeasurementDeclaration]] = None,
parameter_constraints: Optional[List[Union[
str, ParameterConstraint]]] = None,
registry: PulseRegistryType = None) -> None:
"""Creates a new FunctionPulseTemplate object.
Args:
expression: The function represented by this FunctionPulseTemplate
as a mathematical expression where 't' denotes the time variable and other variables
will be parameters of the pulse.
duration_expression: A mathematical expression which reliably
computes the duration of an instantiation of this FunctionPulseTemplate from
provided parameter values.
channel: The channel this pulse template is defined on.
identifier: A unique identifier for use in serialization.
measurements: A list of measurement declarations forwarded to the
:class:`~qupulse.pulses.measurement.MeasurementDefiner` superclass
parameter_constraints: A list of parameter constraints forwarded to the
:class:`~qupulse.pulses.measurement.ParameterConstrainer` superclass
"""
AtomicPulseTemplate.__init__(self,
identifier=identifier,
measurements=measurements)
ParameterConstrainer.__init__(
self, parameter_constraints=parameter_constraints)
self.__expression = ExpressionScalar.make(expression)
self.__duration_expression = ExpressionScalar.make(duration_expression)
self.__parameter_names = {
*self.__duration_expression.variables, *self.__expression.variables
} - {'t'}
self.__channel = channel
self._register(registry=registry)
def __init__(self,
body: PulseTemplate,
repetition_count: Union[int, str, ExpressionScalar],
identifier: Optional[str] = None,
*args,
parameter_constraints: Optional[List] = None,
measurements: Optional[List[MeasurementDeclaration]] = None,
registry: PulseRegistryType = None) -> None:
"""Create a new RepetitionPulseTemplate instance.
Args:
body (PulseTemplate): The PulseTemplate which will be repeated.
repetition_count (int or ParameterDeclaration): The number of repetitions either as a
constant integer value or as a parameter declaration.
identifier (str): A unique identifier for use in serialization. (optional)
"""
if len(args) == 1 and parameter_constraints is None:
warn(
'You used parameter_constraints as a positional argument. It will be keyword only in a future version.',
DeprecationWarning)
elif args:
TypeError(
'RepetitionPulseTemplate expects 3 positional arguments, got '
+ str(3 + len(args)))
LoopPulseTemplate.__init__(self, identifier=identifier, body=body)
ParameterConstrainer.__init__(
self, parameter_constraints=parameter_constraints)
MeasurementDefiner.__init__(self, measurements=measurements)
repetition_count = ExpressionScalar.make(repetition_count)
if repetition_count < 0:
raise ValueError('Repetition count may not be negative')
if repetition_count == 0:
warn(
"Repetition pulse template with 0 repetitions on construction."
)
self._repetition_count = repetition_count
self._register(registry=registry)
def _as_expression(self) -> Dict[ChannelID, ExpressionScalar]:
expr = ExpressionScalar.make(
self.__expression.underlying_expression.subs(
{'t': self._AS_EXPRESSION_TIME}))
return {self.__channel: expr}