qiskit 1.1.2__cp38-abi3-win32.whl → 1.2.0rc1__cp38-abi3-win32.whl

qiskit/circuit/parameter.py

@@ -59,10 +59,10 @@ class Parameter(ParameterExpression):
            bc.draw('mpl')
     """
 
-    __slots__ = ("_name", "_uuid", "_hash")
+    __slots__ = ("_uuid", "_hash")
 
     # This `__init__` does not call the super init, because we can't construct the
-    # `_parameter_symbols` dictionary we need to pass to it before we're entirely initialised
+    # `_parameter_symbols` dictionary we need to pass to it before we're entirely initialized
     # anyway, because `ParameterExpression` depends heavily on the structure of `Parameter`.
 
     def __init__(
@@ -79,7 +79,6 @@ class Parameter(ParameterExpression):
                 field when creating two parameters to the same thing (along with the same name)
                 allows them to be equal.  This is useful during serialization and deserialization.
         """
-        self._name = name
         self._uuid = uuid4() if uuid is None else uuid
         symbol = symengine.Symbol(name)
 
@@ -110,14 +109,14 @@ class Parameter(ParameterExpression):
         if allow_unknown_parameters:
             return self
         raise CircuitError(
-            "Cannot bind Parameters ({}) not present in "
-            "expression.".format([str(p) for p in parameter_map])
+            f"Cannot bind Parameters ({[str(p) for p in parameter_map]}) not present in "
+            "expression."
         )
 
     @property
     def name(self):
         """Returns the name of the :class:`Parameter`."""
-        return self._name
+        return self._symbol_expr.name
 
     @property
     def uuid(self) -> UUID:
@@ -143,7 +142,7 @@ class Parameter(ParameterExpression):
 
     def __eq__(self, other):
         if isinstance(other, Parameter):
-            return (self._uuid, self._name) == (other._uuid, other._name)
+            return (self._uuid, self._symbol_expr) == (other._uuid, other._symbol_expr)
         elif isinstance(other, ParameterExpression):
             return super().__eq__(other)
         else:
@@ -155,7 +154,7 @@ class Parameter(ParameterExpression):
         # expression, so its full hash key is split into `(parameter_keys, symbolic_expression)`.
         # This method lets containing expressions get only the bits they need for equality checks in
         # the first value, without wasting time re-hashing individual Sympy/Symengine symbols.
-        return (self._name, self._uuid)
+        return (self._symbol_expr, self._uuid)
 
     def __hash__(self):
         # This is precached for performance, since it's used a lot and we are immutable.
@@ -165,10 +164,10 @@ class Parameter(ParameterExpression):
     # operation attempts to put this parameter into a hashmap.
 
     def __getstate__(self):
-        return (self._name, self._uuid, self._symbol_expr)
+        return (self.name, self._uuid, self._symbol_expr)
 
     def __setstate__(self, state):
-        self._name, self._uuid, self._symbol_expr = state
+        _, self._uuid, self._symbol_expr = state
         self._parameter_keys = frozenset((self._hash_key(),))
         self._hash = hash((self._parameter_keys, self._symbol_expr))
         self._parameter_symbols = {self: self._symbol_expr}

qiskit/circuit/parameterexpression.py

@@ -48,7 +48,7 @@ class ParameterExpression:
             expr (sympy.Expr): Expression of :class:`sympy.Symbol` s.
         """
         # NOTE: `Parameter.__init__` does not call up to this method, since this method is dependent
-        # on `Parameter` instances already being initialised enough to be hashable.  If changing
+        # on `Parameter` instances already being initialized enough to be hashable.  If changing
         # this method, check that `Parameter.__init__` and `__setstate__` are still valid.
         self._parameter_symbols = symbol_map
         self._parameter_keys = frozenset(p._hash_key() for p in self._parameter_symbols)
@@ -140,7 +140,7 @@ class ParameterExpression:
             raise ZeroDivisionError(
                 "Binding provided for expression "
                 "results in division by zero "
-                "(Expression: {}, Bindings: {}).".format(self, parameter_values)
+                f"(Expression: {self}, Bindings: {parameter_values})."
             )
 
         return ParameterExpression(free_parameter_symbols, bound_symbol_expr)
@@ -199,8 +199,8 @@ class ParameterExpression:
         unknown_parameters = parameters - self.parameters
         if unknown_parameters:
             raise CircuitError(
-                "Cannot bind Parameters ({}) not present in "
-                "expression.".format([str(p) for p in unknown_parameters])
+                f"Cannot bind Parameters ({[str(p) for p in unknown_parameters]}) not present in "
+                "expression."
             )
 
     def _raise_if_passed_nan(self, parameter_values):
@@ -327,8 +327,11 @@ class ParameterExpression:
     def __mul__(self, other):
         return self._apply_operation(operator.mul, other)
 
+    def __pos__(self):
+        return self._apply_operation(operator.mul, 1)
+
     def __neg__(self):
-        return self._apply_operation(operator.mul, -1.0)
+        return self._apply_operation(operator.mul, -1)
 
     def __rmul__(self, other):
         return self._apply_operation(operator.mul, other, reflected=True)
@@ -401,8 +404,8 @@ class ParameterExpression:
         except (TypeError, RuntimeError) as exc:
             if self.parameters:
                 raise TypeError(
-                    "ParameterExpression with unbound parameters ({}) "
-                    "cannot be cast to a complex.".format(self.parameters)
+                    f"ParameterExpression with unbound parameters ({self.parameters}) "
+                    "cannot be cast to a complex."
                 ) from None
             raise TypeError("could not cast expression to complex") from exc
 
@@ -413,13 +416,13 @@ class ParameterExpression:
         except (TypeError, RuntimeError) as exc:
             if self.parameters:
                 raise TypeError(
-                    "ParameterExpression with unbound parameters ({}) "
-                    "cannot be cast to a float.".format(self.parameters)
+                    f"ParameterExpression with unbound parameters ({self.parameters}) "
+                    "cannot be cast to a float."
                 ) from None
             # In symengine, if an expression was complex at any time, its type is likely to have
             # stayed "complex" even when the imaginary part symbolically (i.e. exactly)
-            # cancelled out.  Sympy tends to more aggressively recognise these as symbolically
-            # real.  This second attempt at a cast is a way of unifying the behaviour to the
+            # cancelled out.  Sympy tends to more aggressively recognize these as symbolically
+            # real.  This second attempt at a cast is a way of unifying the behavior to the
             # more expected form for our users.
             cval = complex(self)
             if cval.imag == 0.0:
@@ -433,8 +436,8 @@ class ParameterExpression:
         except RuntimeError as exc:
             if self.parameters:
                 raise TypeError(
-                    "ParameterExpression with unbound parameters ({}) "
-                    "cannot be cast to an int.".format(self.parameters)
+                    f"ParameterExpression with unbound parameters ({self.parameters}) "
+                    "cannot be cast to an int."
                 ) from None
             raise TypeError("could not cast expression to int") from exc
 

qiskit/circuit/parametertable.py

@@ -12,197 +12,8 @@
 """
 Look-up table for variable parameters in QuantumCircuit.
 """
-import operator
-import typing
-from collections.abc import MappingView, MutableMapping, MutableSet
 
-
-class ParameterReferences(MutableSet):
-    """A set of instruction parameter slot references.
-    Items are expected in the form ``(instruction, param_index)``. Membership
-    testing is overridden such that items that are otherwise value-wise equal
-    are still considered distinct if their ``instruction``\\ s are referentially
-    distinct.
-
-    In the case of the special value :attr:`.ParameterTable.GLOBAL_PHASE` for ``instruction``, the
-    ``param_index`` should be ``None``.
-    """
-
-    def _instance_key(self, ref):
-        return (id(ref[0]), ref[1])
-
-    def __init__(self, refs):
-        self._instance_ids = {}
-
-        for ref in refs:
-            if not isinstance(ref, tuple) or len(ref) != 2:
-                raise ValueError("refs must be in form (instruction, param_index)")
-            k = self._instance_key(ref)
-            self._instance_ids[k] = ref[0]
-
-    def __getstate__(self):
-        # Leave behind the reference IDs (keys of _instance_ids) since they'll
-        # be incorrect after unpickling on the other side.
-        return list(self)
-
-    def __setstate__(self, refs):
-        # Recompute reference IDs for the newly unpickled instructions.
-        self._instance_ids = {self._instance_key(ref): ref[0] for ref in refs}
-
-    def __len__(self):
-        return len(self._instance_ids)
-
-    def __iter__(self):
-        for (_, idx), instruction in self._instance_ids.items():
-            yield (instruction, idx)
-
-    def __contains__(self, x) -> bool:
-        return self._instance_key(x) in self._instance_ids
-
-    def __repr__(self) -> str:
-        return f"ParameterReferences({repr(list(self))})"
-
-    def add(self, value):
-        """Adds a reference to the listing if it's not already present."""
-        k = self._instance_key(value)
-        self._instance_ids[k] = value[0]
-
-    def discard(self, value):
-        k = self._instance_key(value)
-        self._instance_ids.pop(k, None)
-
-    def copy(self):
-        """Create a shallow copy."""
-        return ParameterReferences(self)
-
-
-class ParameterTable(MutableMapping):
-    """Class for tracking references to circuit parameters by specific
-    instruction instances.
-
-    Keys are parameters. Values are of type :class:`~ParameterReferences`,
-    which overrides membership testing to be referential for instructions,
-    and is set-like. Elements of :class:`~ParameterReferences`
-    are tuples of ``(instruction, param_index)``.
-    """
-
-    __slots__ = ["_table", "_keys", "_names"]
-
-    class _GlobalPhaseSentinel:
-        __slots__ = ()
-
-        def __copy__(self):
-            return self
-
-        def __deepcopy__(self, memo=None):
-            return self
-
-        def __reduce__(self):
-            return (operator.attrgetter("GLOBAL_PHASE"), (ParameterTable,))
-
-        def __repr__(self):
-            return "<global-phase sentinel>"
-
-    GLOBAL_PHASE = _GlobalPhaseSentinel()
-    """Tracking object to indicate that a reference refers to the global phase of a circuit."""
-
-    def __init__(self, mapping=None):
-        """Create a new instance, initialized with ``mapping`` if provided.
-
-        Args:
-            mapping (Mapping[Parameter, ParameterReferences]):
-                Mapping of parameter to the set of parameter slots that reference
-                it.
-
-        Raises:
-            ValueError: A value in ``mapping`` is not a :class:`~ParameterReferences`.
-        """
-        if mapping is not None:
-            if any(not isinstance(refs, ParameterReferences) for refs in mapping.values()):
-                raise ValueError("Values must be of type ParameterReferences")
-            self._table = mapping.copy()
-        else:
-            self._table = {}
-
-        self._keys = set(self._table)
-        self._names = {x.name: x for x in self._table}
-
-    def __getitem__(self, key):
-        return self._table[key]
-
-    def __setitem__(self, parameter, refs):
-        """Associate a parameter with the set of parameter slots ``(instruction, param_index)``
-        that reference it.
-
-        .. note::
-
-            Items in ``refs`` are considered unique if their ``instruction`` is referentially
-            unique. See :class:`~ParameterReferences` for details.
-
-        Args:
-            parameter (Parameter): the parameter
-            refs (Union[ParameterReferences, Iterable[(Instruction, int)]]): the parameter slots.
-                If this is an iterable, a new :class:`~ParameterReferences` is created from its
-                contents.
-        """
-        if not isinstance(refs, ParameterReferences):
-            refs = ParameterReferences(refs)
-
-        self._table[parameter] = refs
-        self._keys.add(parameter)
-        self._names[parameter.name] = parameter
-
-    def get_keys(self):
-        """Return a set of all keys in the parameter table
-
-        Returns:
-            set: A set of all the keys in the parameter table
-        """
-        return self._keys
-
-    def get_names(self):
-        """Return a set of all parameter names in the parameter table
-
-        Returns:
-            set: A set of all the names in the parameter table
-        """
-        return self._names.keys()
-
-    def parameter_from_name(self, name: str, default: typing.Any = None):
-        """Get a :class:`.Parameter` with references in this table by its string name.
-
-        If the parameter is not present, return the ``default`` value.
-
-        Args:
-            name: The name of the :class:`.Parameter`
-            default: The object that should be returned if the parameter is missing.
-        """
-        return self._names.get(name, default)
-
-    def discard_references(self, expression, key):
-        """Remove all references to parameters contained within ``expression`` at the given table
-        ``key``.  This also discards parameter entries from the table if they have no further
-        references.  No action is taken if the object is not tracked."""
-        for parameter in expression.parameters:
-            if (refs := self._table.get(parameter)) is not None:
-                if len(refs) == 1:
-                    del self[parameter]
-                else:
-                    refs.discard(key)
-
-    def __delitem__(self, key):
-        del self._table[key]
-        self._keys.discard(key)
-        del self._names[key.name]
-
-    def __iter__(self):
-        return iter(self._table)
-
-    def __len__(self):
-        return len(self._table)
-
-    def __repr__(self):
-        return f"ParameterTable({repr(self._table)})"
+from collections.abc import MappingView
 
 
 class ParameterView(MappingView):

qiskit/circuit/parametervector.py

@@ -87,7 +87,7 @@ class ParameterVector:
         return f"{self.name}, {[str(item) for item in self.params]}"
 
     def __repr__(self):
-        return f"{self.__class__.__name__}(name={self.name}, length={len(self)})"
+        return f"{self.__class__.__name__}(name={repr(self.name)}, length={len(self)})"
 
     def resize(self, length):
         """Resize the parameter vector.  If necessary, new elements are generated.