def assign_parameters(self,
value_dict: Dict[ParameterExpression, ParameterValueType]
) -> 'Call':
"""Store parameters which will be later assigned to the subroutine.
Parameter values are not immediately assigned. The subroutine with parameters
assigned according to the populated parameter table will be generated only when
:func:`~qiskit.pulse.transforms.inline_subroutines` function is applied to this
instruction. Note that parameter assignment logic creates a copy of subroutine
to avoid the mutation problem. This function is usually applied by the Qiskit
compiler when the program is submitted to the backend.
Args:
value_dict: A mapping from Parameters to either numeric values or another
Parameter expression.
Returns:
Self with updated parameters.
"""
for param_obj, assigned_value in value_dict.items():
for key_obj, value in self._parameter_table.items():
# assign value to parameter expression (it can consist of multiple parameters)
if isinstance(value, ParameterExpression) and param_obj in value.parameters:
new_value = format_parameter_value(value.assign(param_obj, assigned_value))
self._parameter_table[key_obj] = new_value
return self
def _assign_parameter_expression(self, param_expr: ParameterExpression):
"""A helper function to assign parameter value to parameter expression."""
new_value = copy(param_expr)
for parameter in param_expr.parameters:
if parameter in self._param_map:
new_value = new_value.assign(parameter,
self._param_map[parameter])
return format_parameter_value(new_value)
def assign_parameters(
self, value_dict: Dict[ParameterExpression, ParameterValueType]
) -> "Instruction":
"""Modify and return self with parameters assigned according to the input.
Args:
value_dict: A mapping from Parameters to either numeric values or another
Parameter expression.
Returns:
Self with updated parameters.
"""
new_operands = list(self.operands)
for parameter in self.parameters:
if parameter not in value_dict:
continue
value = value_dict[parameter]
op_indices = self._parameter_table[parameter]
for op_idx in op_indices:
param_expr = new_operands[op_idx]
new_operands[op_idx] = format_parameter_value(
param_expr.assign(parameter, value))
# Update parameter table
entry = self._parameter_table.pop(parameter)
if isinstance(value, ParameterExpression):
for new_parameter in value.parameters:
if new_parameter in self._parameter_table:
new_entry = set(entry +
self._parameter_table[new_parameter])
self._parameter_table[new_parameter] = list(new_entry)
else:
self._parameter_table[new_parameter] = entry
self._operands = tuple(new_operands)
return self
def assign_parameters(self,
value_dict: Dict[ParameterExpression, ParameterValueType]
) -> 'ParametricPulse':
"""Return a new ParametricPulse with parameters assigned.
Args:
value_dict: A mapping from Parameters to either numeric values or another
Parameter expression.
Returns:
New pulse with updated parameters.
"""
if not self.is_parameterized():
return self
new_parameters = {}
for op, op_value in self.parameters.items():
for parameter, value in value_dict.items():
if _is_parameterized(op_value) and parameter in op_value.parameters:
op_value = format_parameter_value(op_value.assign(parameter, value))
new_parameters[op] = op_value
return type(self)(**new_parameters)
