Name-ordered circuit parameters

qiskit/circuit/library/n_local/n_local.py

@@ -20,6 +20,7 @@
 from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit import Instruction, Parameter, ParameterVector, ParameterExpression
 from qiskit.circuit.parametertable import ParameterTable
+from qiskit.utils.deprecation import deprecate_arguments
 
 from ..blueprintcircuit import BlueprintCircuit
 
@@ -735,9 +736,12 @@ def add_layer(self,
 
         return self
 
-    def assign_parameters(self, param_dict: Union[dict, List[float], List[Parameter],
+    @deprecate_arguments({'param_dict': 'parameters'})
+    def assign_parameters(self, parameters: Union[dict, List[float], List[Parameter],
                                                   ParameterVector],
-                          inplace: bool = False) -> Optional[QuantumCircuit]:
+                          inplace: bool = False, *,
+                          param_dict: Optional[dict] = None  # pylint: disable=unused-argument
+                          ) -> Optional[QuantumCircuit]:
         """Assign parameters to the n-local circuit.
 
         This method also supports passing a list instead of a dictionary. If a list
@@ -755,27 +759,27 @@ def assign_parameters(self, param_dict: Union[dict, List[float], List[Parameter]
         if self._data is None:
             self._build()
 
-        if not isinstance(param_dict, dict):
-            if len(param_dict) != self.num_parameters:
+        if not isinstance(parameters, dict):
+            if len(parameters) != self.num_parameters:
                 raise AttributeError('If the parameters are provided as list, the size must match '
                                      'the number of parameters ({}), but {} are given.'.format(
-                                         self.num_parameters, len(param_dict)
+                                         self.num_parameters, len(parameters)
                                      ))
-            unbound_params = [param for param in self._ordered_parameters if
-                              isinstance(param, ParameterExpression)]
+            unbound_parameters = [param for param in self._ordered_parameters if
+                                  isinstance(param, ParameterExpression)]
 
             # to get a sorted list of unique parameters, keep track of the already used parameters
             # in a set and add the parameters to the unique list only if not existing in the set
             used = set()
-            unbound_unique_params = [param for param in unbound_params
-                                     if param not in used and (used.add(param) or True)]
-            param_dict = dict(zip(unbound_unique_params, param_dict))
+            unbound_unique_parameters = [param for param in unbound_parameters
+                                         if param not in used and (used.add(param) or True)]
+            parameters = dict(zip(unbound_unique_parameters, parameters))
 
         if inplace:
-            new = [param_dict.get(param, param) for param in self.ordered_parameters]
+            new = [parameters.get(param, param) for param in self.ordered_parameters]
             self._ordered_parameters = new
 
-        return super().assign_parameters(param_dict, inplace=inplace)
+        return super().assign_parameters(parameters, inplace=inplace)
 
     def _parameterize_block(self, block, param_iter=None, rep_num=None, block_num=None,
                             indices=None, params=None):

qiskit/circuit/parametertable.py

@@ -12,7 +12,9 @@
 """
 Look-up table for variable parameters in QuantumCircuit.
 """
-from collections.abc import MutableMapping
+import warnings
+import functools
+from collections.abc import MutableMapping, MappingView
 
 from .instruction import Instruction
 
@@ -79,3 +81,208 @@ def __len__(self):
 
     def __repr__(self):
         return 'ParameterTable({})'.format(repr(self._table))
+
+
+def _deprecated_set_method():
+    def deprecate(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            # warn only once
+            if not wrapper._warned:
+                warnings.warn(f'The ParameterView.{func.__name__} method is deprecated as of '
+                              'Qiskit Terra 0.17.0 and will be removed no sooner than 3 months '
+                              'after the release date. Circuit parameters are returned as View '
+                              'object, not set. To use set methods you can explicitly cast to a '
+                              'set.', DeprecationWarning, stacklevel=2)
+                wrapper._warned = True
+            return func(*args, **kwargs)
+        wrapper._warned = False
+        return wrapper
+    return deprecate
+
+
+class ParameterView(MappingView):
+    """Temporary class to transition from a set return-type to list.
+
+    Derives from a list but implements all set methods, but all set-methods emit deprecation
+    warnings.
+    """
+
+    def __init__(self, iterable=None):
+        if iterable is not None:
+            self.data = list(iterable)
+        else:
+            self.data = []
+
+        super().__init__(self.data)
+
+    @_deprecated_set_method()
+    def add(self, x):
+        """Add a new element."""
+        if x not in self.data:
+            self.data.append(x)
+
+    def copy(self):
+        """Copy the ParameterView."""
+        return self.__class__(self.data.copy())
+
+    @_deprecated_set_method()
+    def difference(self, *s):
+        """Get the difference between self and the input."""
+        return self.__sub__(s)
+
+    @_deprecated_set_method()
+    def difference_update(self, *s):
+        """Get the difference between self and the input in-place."""
+        for element in self:
+            if element in s:
+                self.remove(element)
+
+    @_deprecated_set_method()
+    def discard(self, x):
+        """Remove an element from self."""
+        if x in self:
+            self.remove(x)
+
+    @_deprecated_set_method()
+    def intersection(self, *x):
+        """Get the intersection between self and the input."""
+        return self.__and__(x)
+
+    @_deprecated_set_method()
+    def intersection_update(self, *x):
+        """Get the intersection between self and the input in-place."""
+        return self.__iand__(x)
+
+    def isdisjoint(self, x):
+        """Check whether self and the input are disjoint."""
+        return not any(element in self for element in x)
+
+    @_deprecated_set_method()
+    def issubset(self, x):
+        """Check whether self is a subset of the input."""
+        return self.__le__(x)
+
+    @_deprecated_set_method()
+    def issuperset(self, x):
+        """Check whether self is a superset of the input."""
+        return self.__ge__(x)
+
+    @_deprecated_set_method()
+    def symmetric_difference(self, x):
+        """Get the symmetric difference of self and the input."""
+        return self.__xor__(x)
+
+    @_deprecated_set_method()
+    def symmetric_difference_update(self, x):
+        """Get the symmetric difference of self and the input in-place."""
+        backward = x.difference(self)
+        self.difference_update(x)
+        self.update(backward)
+
+    @_deprecated_set_method()
+    def union(self, *x):
+        """Get the union of self and the input."""
+        return self.__or__(x)
+
+    @_deprecated_set_method()
+    def update(self, *x):
+        """Update self with the input."""
+        for element in x:
+            self.add(element)
+
+    def remove(self, x):
+        """Remove an existing element from the view."""
+        self.data.remove(x)
+
+    def __repr__(self):
+        """Format the class as string."""
+        return f'ParameterView({self.data})'
+
+    def __getitem__(self, index):
+        """Get items."""
+        return self.data[index]
+
+    def __and__(self, x):
+        """Get the intersection between self and the input."""
+        inter = []
+        for element in self:
+            if element in x:
+                inter.append(element)
+
+        return self.__class__(inter)
+
+    def __rand__(self, x):
+        """Get the intersection between self and the input."""
+        return self.__and__(x)
+
+    def __iand__(self, x):
+        """Get the intersection between self and the input in-place."""
+        for element in self:
+            if element not in x:
+                self.remove(element)
+        return self
+
+    def __len__(self):
+        """Get the length."""
+        return len(self.data)
+
+    def __or__(self, x):
+        """Get the union of self and the input."""
+        return set(self) | set(x)
+
+    def __ior__(self, x):
+        """Update self with the input."""
+        self.update(*x)
+        return self
+
+    def __sub__(self, x):
+        """Get the difference between self and the input."""
+        return set(self) - set(x)
+
+    @_deprecated_set_method()
+    def __isub__(self, x):
+        """Get the difference between self and the input in-place."""
+        return self.difference_update(*x)
+
+    def __xor__(self, x):
+        """Get the symmetric difference between self and the input."""
+        return set(self) ^ set(x)
+
+    @_deprecated_set_method()
+    def __ixor__(self, x):
+        """Get the symmetric difference between self and the input in-place."""
+        self.symmetric_difference_update(x)
+        return self
+
+    def __ne__(self, other):
+        return set(other) != set(self)
+
+    def __eq__(self, other):
+        return set(other) == set(self)
+
+    def __le__(self, x):
+        return all(element in x for element in self)
+
+    def __lt__(self, x):
+        if x != self:
+            return self <= x
+        return False
+
+    def __ge__(self, x):
+        return all(element in self for element in x)
+
+    def __gt__(self, x):
+        if x != self:
+            return self >= x
+        return False
+
+    def __iter__(self):
+        return iter(self.data)
+
+    def __contains__(self, x):
+        return x in self.data
+
+    __hash__: None  # type: ignore
+    __rand__ = __and__
+    __ror__ = __or__

qiskit/circuit/parametervector.py

@@ -12,9 +12,45 @@
 
 """Parameter Vector Class to simplify management of parameter lists."""
 
+from uuid import uuid4
+
 from .parameter import Parameter
 
 
+class ParameterVectorElement(Parameter):
+    """An element of a ParameterVector."""
+
+    def __new__(cls, vector_name, index, uuid=None):  # pylint:disable=unused-argument
+        obj = object.__new__(cls)
+
+        if uuid is None:
+            obj._uuid = uuid4()
+        else:
+            obj._uuid = uuid
+
+        obj._hash = hash(obj._uuid)
+        return obj
+
+    def __getnewargs__(self):
+        return (self.vector_name, self.index, self._uuid)
+
+    def __init__(self, vector_name, index):
+        name = f'{vector_name}[{index}]'
+        super().__init__(name)
+        self._vector_name = vector_name
+        self._index = index
+
+    @property
+    def index(self):
+        """Get the index of this element in the parameter vector."""
+        return self._index
+
+    @property
+    def vector_name(self):
+        """Get the name of the vector."""
+        return self._vector_name
+
+
 class ParameterVector:
     """ParameterVector class to quickly generate lists of parameters."""
 
@@ -23,7 +59,7 @@ def __init__(self, name, length=0):
         self._params = []
         self._size = length
         for i in range(length):
-            self._params += [Parameter('{}[{}]'.format(self._name, i))]
+            self._params += [ParameterVectorElement(name, i)]
 
     @property
     def name(self):
@@ -69,5 +105,5 @@ def resize(self, length):
         """
         if length > len(self._params):
             for i in range(len(self._params), length):
-                self._params += [Parameter('{}[{}]'.format(self._name, i))]
+                self._params += [ParameterVectorElement(self.name, i)]
         self._size = length