pyGSTi 0.9.12__cp39-cp39-win32.whl → 0.9.13__cp39-cp39-win32.whl

pygsti/baseobjs/errorgenbasis.py

@@ -79,11 +79,6 @@ class ExplicitElementaryErrorgenBasis(ElementaryErrorgenBasis):
             return None
         return self._label_indices[label]
 
-    #@property
-    #def sslbls(self):
-    #    """ The support of this errorgen space, e.g., the qubits where its elements may be nontrivial """
-    #    return self.sslbls
-
     def create_subbasis(self, must_overlap_with_these_sslbls):
         """
         Create a sub-basis of this basis by including only the elements
@@ -491,11 +486,6 @@ class CompleteElementaryErrorgenBasis(ElementaryErrorgenBasis):
 
         return base + indices[elemgen_label]
 
-    #@property
-    #def sslbls(self):
-    #    """ The support of this errorgen space, e.g., the qubits where its elements may be nontrivial """
-    #    return self.sslbls
-
     def create_subbasis(self, must_overlap_with_these_sslbls, retain_max_weights=True):
         """
         Create a sub-basis of this basis by including only the elements
@@ -524,125 +514,3 @@ class CompleteElementaryErrorgenBasis(ElementaryErrorgenBasis):
 
     def difference(self, other_basis):
         return self.to_explicit_basis().difference(other_basis)
-
-
-#OLD - maybe not needed?
-#class LowWeightElementaryErrorgenBasis(ElementaryErrorgenBasis):
-#    """
-#    Spanned by the elementary error generators of given type(s) (e.g. "Hamiltonian" and/or "other")
-#    and with elements corresponding to a `Basis`, usually of Paulis.
-#    """
-#
-#    def __init__(self, basis_1q, state_space, other_mode, max_ham_weight=None, max_other_weight=None,
-#                 must_overlap_with_these_sslbls=None):
-#        self._basis_1q = basis_1q
-#        self._other_mode = other_mode
-#        self.state_space = state_space
-#        self._max_ham_weight = max_ham_weight
-#        self._max_other_weight = max_other_weight
-#        self._must_overlap_with_these_sslbls = must_overlap_with_these_sslbls
-#
-#        assert(self.state_space.is_entirely_qubits), "FOGI only works for models containing just qubits (so far)"
-#        sslbls = self.state_space.sole_tensor_product_block_labels  # all the model's state space labels
-#        self.sslbls = sslbls  # the "support" of this space - the qubit labels
-#
-#        self._cached_label_indices = None
-#        self._cached_labels_by_support = None
-#        self._cached_elements = None
-#
-#        #Needed?
-#        # self.dim = len(self.labels)  # TODO - update this so we don't always need to build labels
-#        # # (this defeats lazy building via property below) - we can just compute this, especially if
-#        # # not too fancy
-#
-#    @property
-#    def labels(self):
-#        if self._cached_label_indices is None:
-#
-#            def _basis_el_strs(possible_bels, wt):
-#                for els in _itertools.product(*([possible_bels] * wt)):
-#                    yield ''.join(els)
-#
-#            labels = {}
-#            all_bels = self.basis_1q.labels[1:]  # assume first element is identity
-#            nontrivial_bels = self.basis_1q.labels[1:]  # assume first element is identity
-#
-#            max_weight = self._max_ham_weight if (self._max_ham_weight is not None) else len(self.sslbls)
-#            for weight in range(1, max_weight + 1):
-#                for support in _itertools.combinations(self.sslbls, weight):
-#                    if (self._must_overlap_with_these_sslbls is not None
-#                       and len(self._must_overlap_with_these_sslbls.intersection(support)) == 0):
-#                        continue
-#                    if support not in labels: labels[support] = []  # always True?
-#                    labels[support].extend([('H', bel) for bel in _basis_el_strs(nontrivial_bels, weight)])
-#
-#            max_weight = self._max_other_weight if (self._max_other_weight is not None) else len(self.sslbls)
-#            if self._other_mode != "all":
-#                for weight in range(1, max_weight + 1):
-#                    for support in _itertools.combinations(self.sslbls, weight):
-#                        if (self._must_overlap_with_these_sslbls is not None
-#                           and len(self._must_overlap_with_these_sslbls.intersection(support)) == 0):
-#                            continue
-#                        if support not in labels: labels[support] = []
-#                        labels[support].extend([('S', bel) for bel in _basis_el_strs(nontrivial_bels, weight)])
-#            else:
-#                #This is messy code that relies on basis labels being single characters -- TODO improve(?)
-#                idle_char = self.basis_1q.labels[1:]  # assume first element is identity
-#                assert(len(idle_char) == 1 and all([len(c) == 1 for c in nontrivial_bels])), \
-#                    "All basis el labels must be single chars for other_mode=='all'!"
-#                for support in _itertools.combinations(self.sslbls, max_weight):
-#                    # Loop over all possible basis elements for this max-weight support, computing the actual support
-#                    # of each one individually and appending it to the appropriate list
-#                    for bel1 in _basis_el_strs(all_bels, max_weight):
-#                        nonidle_indices1 = [i for i in range(max_weight) if bel1[i] != idle_char]
-#                        for bel2 in _basis_el_strs(all_bels, max_weight):
-#                            nonidle_indices2 = [i for i in range(max_weight) if bel2[i] != idle_char]
-#                            nonidle_indices = list(sorted(set(nonidle_indices1) + set(nonidle_indices2)))
-#                            bel1 = ''.join([bel1[i] for i in nonidle_indices])  # trim to actual support
-#                            bel2 = ''.join([bel2[i] for i in nonidle_indices])  # trim to actual support
-#                            actual_support = tuple([support[i] for i in nonidle_indices])
-#
-#                            if (self._must_overlap_with_these_sslbls is not None
-#                               and len(self._must_overlap_with_these_sslbls.intersection(actual_support)) == 0):
-#                                continue
-#
-#                            if actual_support not in labels: labels[actual_support] = []
-#                            labels[actual_support].append(('S', bel1, bel2))
-#
-#            self._cached_labels_by_support = labels
-#            self._cached_label_indices = _collections.OrderedDict(((support_lbl, i) for i, support_lbl in enumerate(
-#                ((support, lbl) for support, lst in labels.items() for lbl in lst))))
-#
-#        return tuple(self._cached_label_indices.keys())
-#
-#    @property
-#    def element_supports_and_matrices(self):
-#        if self._cached_elements is None:
-#            self._cached_elements = tuple(
-#                ((support, _ot.lindblad_error_generator(elemgen_label, self.basis_1q, normalize=True, sparse=False))
-#                 for support, elemgen_label in self.labels))
-#        return self._cached_elements
-#
-#    def element_index(self, label):
-#        """
-#        TODO: docstring
-#        """
-#        if self._cached_label_indices is None:
-#            self.labels  # triggers building of labels
-#        return self._cached_label_indices[label]
-#
-#    @property
-#    def sslbls(self):
-#        """ The support of this errorgen space, e.g., the qubits where its elements may be nontrivial """
-#        return self.sslbls
-#
-#    def create_subbasis(self, must_overlap_with_these_sslbls, retain_max_weights=True):
-#        """
-#        Create a sub-basis of this basis by including only the elements
-#        that overlap the given support (state space labels)
-#        """
-#        #Note: can we reduce self.state_space?
-#        return CompleteErrorgenBasis(self._basis_1q, self.state_space, self._other_mode,
-#                                     self._max_ham_weight if retain_max_weights else None,
-#                                     self._max_other_weight if retain_max_weights else None,
-#                                     self._must_overlap_with_these_sslbls)

pygsti/baseobjs/errorgenspace.py

@@ -97,13 +97,3 @@ class ErrorgenSpace(object):
         for j in range(self.vectors.shape[1]):
             sign = +1 if max(self.vectors[:, j]) >= -min(self.vectors[:, j]) else -1
             self.vectors[:, j] /= sign * _np.linalg.norm(self.vectors[:, j], ord=norm_order)
-
-
-#class LowWeightErrorgenSpace(ErrorgenSpace):
-#    """
-#    Like a SimpleErrorgenSpace but spanned by only the elementary error generators corresponding to
-#    low-weight (up to some maximum weight) basis elements
-#    (so far, only Pauli-product bases work for this, since `Basis` objects don't keep track of each
-#    element's weight (?)).
-#    """
-#    pass

pygsti/baseobjs/label.py

@@ -14,8 +14,6 @@ import itertools as _itertools
 import numbers as _numbers
 import sys as _sys
 
-_debug_record = {}
-
 
 class Label(object):
     """
@@ -63,12 +61,11 @@ class Label(object):
             could be an argument of a gate label, and one might create a label:
             `Label('Gx', (0,), args=(pi/3,))`
         """
-        #print("Label.__new__ with name=", name, "sslbls=", state_space_labels, "t=", time, "args=", args)
+        
         if isinstance(name, Label) and state_space_labels is None:
             return name  # Note: Labels are immutable, so no need to copy
 
-        if not isinstance(name, str) and state_space_labels is None \
-           and isinstance(name, (tuple, list)):
+        if isinstance(name, (tuple, list)) and state_space_labels is None:
 
             #We're being asked to initialize from a non-string with no
             # state_space_labels, explicitly given.  `name` could either be:
@@ -190,6 +187,15 @@ class Label(object):
             :class:`CircuitLabel` objects).
         """
         return (self,)  # most labels just expand to themselves
+    
+    @property
+    def is_simple(self):
+        """
+        Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.    
+        """
+
+        return self.IS_SIMPLE
+
 
 
 class LabelTup(Label, tuple):
@@ -201,6 +207,10 @@ class LabelTup(Label, tuple):
     acted upon by the object this label refers to.
     """
 
+    #flag used in certain Circuit subroutines
+    #Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
+    IS_SIMPLE = True
+
     @classmethod
     def init(cls, name, state_space_labels):
         """
@@ -250,10 +260,6 @@ class LabelTup(Label, tuple):
         return tuple.__new__(cls, tup)
 
     __new__ = tuple.__new__
-    #def __new__(cls, tup, time=0.0):
-    #    ret = tuple.__new__(cls, tup)  # creates a LabelTup object using tuple's __new__
-    #    ret.time = time
-    #    return ret
 
     @property
     def time(self):
@@ -354,26 +360,10 @@ class LabelTup(Label, tuple):
             mapped_sslbls = [mapper(sslbl) for sslbl in self.sslbls]
         return Label(self.name, mapped_sslbls)
 
-    #OLD
-    #def __iter__(self):
-    #    return self.tup.__iter__()
-
-    #OLD
-    #def __iter__(self):
-    #    """ Iterate over the name + state space labels """
-    #    # Note: tuple(.) uses __iter__ to construct tuple rep.
-    #    yield self.name
-    #    if self.sslbls is not None:
-    #        for ssl in self.sslbls:
-    #            yield ssl
-
     def __str__(self):
         """
         Defines how a Label is printed out, e.g. Gx:0 or Gcnot:1:2
         """
-        #caller = inspect.getframeinfo(inspect.currentframe().f_back)
-        #ky = "%s:%s:%d" % (caller[2],os.path.basename(caller[0]),caller[1])
-        #_debug_record[ky] = _debug_record.get(ky, 0) + 1
         s = str(self.name)
         if self.sslbls:  # test for None and len == 0
             s += ":" + ":".join(map(str, self.sslbls))
@@ -393,13 +383,7 @@ class LabelTup(Label, tuple):
         Defines equality between gates, so that they are equal if their values
         are equal.
         """
-        #Unnecessary now that we have a separate LabelStr
-        #if isinstance(other, str):
-        #    if self.sslbls: return False # tests for None and len > 0
-        #    return self.name == other
-
         return tuple.__eq__(self, other)
-        #OLD return self.name == other.name and self.sslbls == other.sslbls # ok to compare None
 
     def __lt__(self, x):
         return tuple.__lt__(self, tuple(x))
@@ -445,16 +429,6 @@ class LabelTup(Label, tuple):
         """
         return LabelTup.init(newname, self.sslbls) if (self.name == oldname) else self
 
-    def is_simple(self):
-        """
-        Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
-
-        Returns
-        -------
-        bool
-        """
-        return True
-
     __hash__ = tuple.__hash__  # this is why we derive from tuple - using the
     # native tuple.__hash__ directly == speed boost
 
@@ -468,6 +442,10 @@ class LabelTupWithTime(Label, tuple):
     acted upon by the object this label refers to.
     """
 
+    #flag used in certain Circuit subroutines
+    #Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
+    IS_SIMPLE = True
+
     @classmethod
     def init(cls, name, state_space_labels, time=0.0):
         """
@@ -617,19 +595,6 @@ class LabelTupWithTime(Label, tuple):
             mapped_sslbls = [mapper(sslbl) for sslbl in self.sslbls]
         return Label(self.name, mapped_sslbls)
 
-    #OLD
-    #def __iter__(self):
-    #    return self.tup.__iter__()
-
-    #OLD
-    #def __iter__(self):
-    #    """ Iterate over the name + state space labels """
-    #    # Note: tuple(.) uses __iter__ to construct tuple rep.
-    #    yield self.name
-    #    if self.sslbls is not None:
-    #        for ssl in self.sslbls:
-    #            yield ssl
-
     def __str__(self):
         """
         Defines how a Label is printed out, e.g. Gx:0 or Gcnot:1:2
@@ -659,13 +624,8 @@ class LabelTupWithTime(Label, tuple):
         Defines equality between gates, so that they are equal if their values
         are equal.
         """
-        #Unnecessary now that we have a separate LabelStr
-        #if isinstance(other, str):
-        #    if self.sslbls: return False # tests for None and len > 0
-        #    return self.name == other
 
         return tuple.__eq__(self, other)
-        #OLD return self.name == other.name and self.sslbls == other.sslbls # ok to compare None
 
     def __lt__(self, x):
         return tuple.__lt__(self, tuple(x))
@@ -711,16 +671,6 @@ class LabelTupWithTime(Label, tuple):
         """
         return LabelTupWithTime(newname, self.sslbls) if (self.name == oldname) else self
 
-    def is_simple(self):
-        """
-        Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
-
-        Returns
-        -------
-        bool
-        """
-        return True
-
     __hash__ = tuple.__hash__  # this is why we derive from tuple - using the
     # native tuple.__hash__ directly == speed boost
 
@@ -736,6 +686,10 @@ class LabelStr(Label, str):
     the hashing gets *much* slower.
     """
 
+    #flag used in certain Circuit subroutines
+    #Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
+    IS_SIMPLE = True
+
     @classmethod
     def init(cls, name, time=0.0):
         """
@@ -863,6 +817,10 @@ class LabelStr(Label, str):
         # Need to tell serialization logic how to create a new Label since it's derived
         # from the immutable tuple type (so cannot have its state set after creation)
         return (LabelStr, (str(self), self.time), None)
+    
+    def __contains__(self, x):
+        #need to get a string rep of the tested label.
+        return str(x) in str(self)
 
     def to_native(self):
         """
@@ -894,16 +852,6 @@ class LabelStr(Label, str):
         """
         return LabelStr(newname) if (self.name == oldname) else self
 
-    def is_simple(self):
-        """
-        Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
-
-        Returns
-        -------
-        bool
-        """
-        return True
-
     __hash__ = str.__hash__  # this is why we derive from tuple - using the
     # native tuple.__hash__ directly == speed boost
 
@@ -915,6 +863,10 @@ class LabelTupTup(Label, tuple):
     This typically labels a layer of a circuit (a parallel level of gates).
     """
 
+    #flag used in certain Circuit subroutines
+    #Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
+    IS_SIMPLE = False
+
     @classmethod
     def init(cls, tup_of_tups):
         """
@@ -934,9 +886,9 @@ class LabelTupTup(Label, tuple):
         -------
         LabelTupTup
         """
-        tupOfLabels = tuple((Label(tup) for tup in tup_of_tups))  # Note: tup can also be a Label obj
-        if len(tupOfLabels) > 0:
-            assert(max([lbl.time for lbl in tupOfLabels]) == 0.0), \
+        tupOfLabels = tuple([Label(tup) for tup in tup_of_tups])  # Note: tup can also be a Label obj
+        if tupOfLabels:
+            assert(all([lbl.time==0.0 for lbl in tupOfLabels])), \
                 "Cannot create a LabelTupTup containing labels with time != 0"
         return cls.__new__(cls, tupOfLabels)
 
@@ -1071,13 +1023,7 @@ class LabelTupTup(Label, tuple):
         Defines equality between gates, so that they are equal if their values
         are equal.
         """
-        #Unnecessary now that we have a separate LabelStr
-        #if isinstance(other, str):
-        #    if self.sslbls: return False # tests for None and len > 0
-        #    return self.name == other
-
         return tuple.__eq__(self, other)
-        #OLD return self.name == other.name and self.sslbls == other.sslbls # ok to compare None
 
     def __lt__(self, x):
         return tuple.__lt__(self, tuple(x))
@@ -1127,16 +1073,6 @@ class LabelTupTup(Label, tuple):
         """
         return LabelTupTup(tuple((x.replace_name(oldname, newname) for x in self)))
 
-    def is_simple(self):
-        """
-        Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
-
-        Returns
-        -------
-        bool
-        """
-        return False
-
     @property
     def depth(self):
         """
@@ -1182,6 +1118,10 @@ class LabelTupTupWithTime(Label, tuple):
     This typically labels a layer of a circuit (a parallel level of gates).
     """
 
+    #flag used in certain Circuit subroutines
+    #Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
+    IS_SIMPLE = False
+
     @classmethod
     def init(cls, tup_of_tups, time=None):
         """
@@ -1340,13 +1280,7 @@ class LabelTupTupWithTime(Label, tuple):
         Defines equality between gates, so that they are equal if their values
         are equal.
         """
-        #Unnecessary now that we have a separate LabelStr
-        #if isinstance(other, str):
-        #    if self.sslbls: return False # tests for None and len > 0
-        #    return self.name == other
-
         return tuple.__eq__(self, other)
-        #OLD return self.name == other.name and self.sslbls == other.sslbls # ok to compare None
 
     def __lt__(self, x):
         return tuple.__lt__(self, tuple(x))
@@ -1396,16 +1330,6 @@ class LabelTupTupWithTime(Label, tuple):
         """
         return LabelTupTupWithTime(tuple((x.replace_name(oldname, newname) for x in self)))
 
-    def is_simple(self):
-        """
-        Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
-
-        Returns
-        -------
-        bool
-        """
-        return False
-
     @property
     def depth(self):
         """
@@ -1454,6 +1378,11 @@ class CircuitLabel(Label, tuple):
     (held as the label's components) and line labels (held as the label's
     state-space labels)
     """
+
+    #flag used in certain Circuit subroutines
+    #Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
+    IS_SIMPLE = True
+
     def __new__(cls, name, tup_of_layers, state_space_labels, reps=1, time=None):
         # Note: may need default args for all but 1st for pickling!
         """
@@ -1633,13 +1562,7 @@ class CircuitLabel(Label, tuple):
         Defines equality between gates, so that they are equal if their values
         are equal.
         """
-        #Unnecessary now that we have a separate LabelStr
-        #if isinstance(other, str):
-        #    if self.sslbls: return False # tests for None and len > 0
-        #    return self.name == other
-
         return tuple.__eq__(self, other)
-        #OLD return self.name == other.name and self.sslbls == other.sslbls # ok to compare None
 
     def __lt__(self, x):
         return tuple.__lt__(self, tuple(x))
@@ -1692,16 +1615,6 @@ class CircuitLabel(Label, tuple):
                             self.sslbls,
                             self[2])
 
-    def is_simple(self):
-        """
-        Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
-
-        Returns
-        -------
-        bool
-        """
-        return True  # still true - even though can have components!
-
     @property
     def depth(self):
         """
@@ -1729,11 +1642,6 @@ class CircuitLabel(Label, tuple):
     # native tuple.__hash__ directly == speed boost
 
 
-#class NamedLabelTupTup(Label,tuple):
-#    def __new__(cls,name,tup_of_tups):
-#        pass
-
-
 class LabelTupWithArgs(Label, tuple):
     """
     A label consisting of a string along with a tuple of integers or state-space-names.
@@ -1743,6 +1651,10 @@ class LabelTupWithArgs(Label, tuple):
     refers to.  This label type also supports having arguments and a time value.
     """
 
+    #flag used in certain Circuit subroutines
+    #Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
+    IS_SIMPLE = True
+
     @classmethod
     def init(cls, name, state_space_labels, time=0.0, args=()):
         """
@@ -1943,13 +1855,7 @@ class LabelTupWithArgs(Label, tuple):
         Defines equality between gates, so that they are equal if their values
         are equal.
         """
-        #Unnecessary now that we have a separate LabelStr
-        #if isinstance(other, str):
-        #    if self.sslbls: return False # tests for None and len > 0
-        #    return self.name == other
-
         return tuple.__eq__(self, other)
-        #OLD return self.name == other.name and self.sslbls == other.sslbls # ok to compare None
 
     def __lt__(self, x):
         try:
@@ -2001,16 +1907,6 @@ class LabelTupWithArgs(Label, tuple):
         """
         return LabelTupWithArgs(newname, self.sslbls, self.time, self.args) if (self.name == oldname) else self
 
-    def is_simple(self):
-        """
-        Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
-
-        Returns
-        -------
-        bool
-        """
-        return True
-
     __hash__ = tuple.__hash__  # this is why we derive from tuple - using the
     # native tuple.__hash__ directly == speed boost
 
@@ -2023,6 +1919,10 @@ class LabelTupTupWithArgs(Label, tuple):
     This label type also supports having arguments and a time value.
     """
 
+    #flag used in certain Circuit subroutines
+    #Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
+    IS_SIMPLE = False
+
     @classmethod
     def init(cls, tup_of_tups, time=None, args=()):
         """
@@ -2199,14 +2099,8 @@ class LabelTupTupWithArgs(Label, tuple):
         Defines equality between gates, so that they are equal if their values
         are equal.
         """
-        #Unnecessary now that we have a separate LabelStr
-        #if isinstance(other, str):
-        #    if self.sslbls: return False # tests for None and len > 0
-        #    return self.name == other
-
         return tuple.__eq__(self, other)
-        #OLD return self.name == other.name and self.sslbls == other.sslbls # ok to compare None
-
+        
     def __lt__(self, x):
         return tuple.__lt__(self, tuple(x))
 
@@ -2256,16 +2150,6 @@ class LabelTupTupWithArgs(Label, tuple):
         return LabelTupTupWithArgs(tuple((x.replace_name(oldname, newname) for x in self.components)),
                                    self.time, self.args)
 
-    def is_simple(self):
-        """
-        Whether this is a "simple" (opaque w/a true name, from a circuit perspective) label or not.
-
-        Returns
-        -------
-        bool
-        """
-        return False
-
     @property
     def depth(self):
         """

pygsti/baseobjs/opcalc/fastopcalc.pyx

@@ -69,7 +69,7 @@ def bulk_eval_compact_polynomials_real(np.ndarray[np.int64_t, ndim=1, mode="c"]
                                  np.ndarray[double, ndim=1, mode="c"] ctape,
                                  np.ndarray[double, ndim=1, mode="c"] paramvec,
                                  dest_shape):
-    cdef INT dest_size = np.product(dest_shape)
+    cdef INT dest_size = np.prod(dest_shape)
     cdef np.ndarray[np.float64_t, ndim=1, mode="c"] res = np.empty(dest_size, np.float64)
 
     cdef INT c = 0
@@ -108,7 +108,7 @@ def bulk_eval_compact_polynomials_complex(np.ndarray[np.int64_t, ndim=1, mode="c
                                     np.ndarray[double, ndim=1, mode="c"] paramvec,
                                     dest_shape):
     cdef INT k
-    cdef INT dest_size = 1  # np.product(dest_shape) #SLOW!
+    cdef INT dest_size = 1  # np.prod(dest_shape) #SLOW!
     for k in range(len(dest_shape)):
         dest_size *= dest_shape[k]
     cdef np.ndarray[np.complex128_t, ndim=1, mode="c"] res = np.empty(dest_size, np.complex128)