pyGSTi 0.9.12.1__cp38-cp38-win_amd64.whl → 0.9.13__cp38-cp38-win_amd64.whl

pygsti/evotypes/densitymx/statereps.pyx

@@ -163,7 +163,7 @@ cdef class StateRepTensorProduct(StateRep):
 
     def __cinit__(self, factor_state_reps, state_space):
         self.factor_reps = factor_state_reps
-        dim = _np.product([fct.dim for fct in self.factor_reps])
+        dim = _np.prod([fct.dim for fct in self.factor_reps])
         self._cinit_base(_np.zeros(dim, 'd'), state_space)
         self.reps_have_changed()
 

pygsti/evotypes/densitymx_slow/effectreps.py

@@ -13,12 +13,13 @@ POVM effect representation classes for the `densitymx_slow` evolution type.
 import numpy as _np
 
 # import functools as _functools
-from .. import basereps as _basereps
 from pygsti.baseobjs.statespace import StateSpace as _StateSpace
 from ...tools import matrixtools as _mt
 
 
-class EffectRep(_basereps.EffectRep):
+class EffectRep:
+    """Any representation of an "effect" in the sense of a POVM."""
+
     def __init__(self, state_space):
         self.state_space = _StateSpace.cast(state_space)
 
@@ -27,6 +28,10 @@ class EffectRep(_basereps.EffectRep):
 
 
 class EffectRepConjugatedState(EffectRep):
+    """
+    A real superket representation of an "effect" in the sense of a POVM.
+    Internally uses a StateRepDense object to hold the real superket.
+    """
 
     def __init__(self, state_rep):
         self.state_rep = state_rep
@@ -100,11 +105,6 @@ class EffectRepTensorProduct(EffectRep):
         super(EffectRepTensorProduct, self).__init__(state_space)
         self.factor_effects_have_changed()
 
-    #TODO: fix this:
-    #def __reduce__(self):
-    #    return (EffectRepTensorProduct,
-    #            (self.kron_array, self.factor_dims, self.nfactors, self.max_factor_dim, self.dim))
-
     def to_dense(self, on_space, outvec=None):
 
         if on_space not in ('minimal', 'HilbertSchmidt'):
@@ -159,22 +159,6 @@ class EffectRepTensorProduct(EffectRep):
     def factor_effects_have_changed(self):
         self._fill_fast_kron()  # updates effect reps
 
-    #def to_dense(self):
-    #    if len(self.factors) == 0: return _np.empty(0, complex if self._evotype == "statevec" else 'd')
-    #        #NOTE: moved a fast version of to_dense to replib - could use that if need a fast to_dense call...
-    #
-    #        factorPOVMs = self.factors
-    #        ret = factorPOVMs[0][self.effectLbls[0]].to_dense()
-    #        for i in range(1, len(factorPOVMs)):
-    #            ret = _np.kron(ret, factorPOVMs[i][self.effectLbls[i]].to_dense())
-    #        return ret
-    #    elif self._evotype == "stabilizer":
-    #        # each factor is a StabilizerEffectVec
-    #        raise ValueError("Cannot convert Stabilizer tensor product effect to an array!")
-    #    # should be using effect.outcomes property...
-    #    else:  # self._evotype in ("svterm","cterm")
-    #        raise NotImplementedError("to_dense() not implemented for %s evolution type" % self._evotype)
-
 
 class EffectRepComposed(EffectRep):
     def __init__(self, op_rep, effect_rep, op_id, state_space):

pygsti/evotypes/densitymx_slow/opreps.py

@@ -17,7 +17,6 @@ import scipy.sparse as _sps
 from scipy.sparse.linalg import LinearOperator
 
 from .statereps import StateRepDense as _StateRepDense
-from .. import basereps as _basereps
 from pygsti.baseobjs.statespace import StateSpace as _StateSpace
 from ...tools import basistools as _bt
 from ...tools import internalgates as _itgs
@@ -26,7 +25,11 @@ from ...tools import matrixtools as _mt
 from ...tools import optools as _ot
 
 
-class OpRep(_basereps.OpRep):
+class OpRep:
+    """
+    A real superoperator on Hilbert-Schmidt space.
+    """
+
     def __init__(self, state_space):
         self.state_space = state_space
 
@@ -41,6 +44,10 @@ class OpRep(_basereps.OpRep):
         raise NotImplementedError()
 
     def aslinearoperator(self):
+        """
+        Return a SciPy LinearOperator that accepts superket representations of vectors
+        in Hilbert-Schmidt space and returns a vector of that same representation.
+        """
         def mv(v):
             if v.ndim == 2 and v.shape[1] == 1: v = v[:, 0]
             in_state = _StateRepDense(_np.ascontiguousarray(v, 'd'), self.state_space, None)
@@ -54,6 +61,12 @@ class OpRep(_basereps.OpRep):
 
 
 class OpRepDenseSuperop(OpRep):
+    """
+    A real superoperator on Hilbert-Schmidt space.
+    The operator's action (and adjoint action) work with Hermitian matrices
+    stored as *vectors* in their real superket representations.
+    """
+
     def __init__(self, mx, basis, state_space):
         state_space = _StateSpace.cast(state_space)
         if mx is None:
@@ -174,7 +187,7 @@ class OpRepStandard(OpRepDenseSuperop):
         state_space = _StateSpace.cast(state_space)
         assert(superop.shape[0] == state_space.dim)
 
-        super(OpRepStandard, self).__init__(superop, state_space)
+        super(OpRepStandard, self).__init__(superop, basis, state_space)
 
 
 class OpRepKraus(OpRep):
@@ -257,10 +270,6 @@ class OpRepStochastic(OpRepRandomUnitary):
         self.rates[:] = rates
         self.update_unitary_rates(unitary_rates)
 
-#class OpRepClifford(OpRep):  # TODO?
-#    #def __init__(self, unitarymx, symplecticrep):
-#    #    pass
-
 
 class OpRepComposed(OpRep):
 
@@ -362,13 +371,6 @@ class OpRepEmbedded(OpRep):
         self.offset = sum(blocksizes[0:self.active_block_index])
         super(OpRepEmbedded, self).__init__(state_space)
 
-    #def __reduce__(self):
-    #    return (DMOpRepEmbedded, (self.embedded,
-    #                              self.num_basis_els, self.action_inds,
-    #                              self.blocksizes, self.embeddedDim,
-    #                              self.ncomponents, self.active_block_index,
-    #                              self.nblocks, self.dim))
-
     def _acton_other_blocks_trivially(self, output_state, state):
         offset = 0
         for iBlk, blockSize in enumerate(self.blocksizes):
@@ -453,15 +455,6 @@ class OpRepExpErrorgen(OpRep):
     def exp_params(self):
         return (self.mu, self.eta, self.m_star, self.s)
 
-    #def __reduce__(self):
-    #    if self.unitary_postfactor is None:
-    #        return (DMOpRepLindblad, (self.errorgen_rep, self.mu, self.eta, self.m_star, self.s,
-    #                                  _np.empty(0, 'd'), _np.empty(0, _np.int64), _np.zeros(1, _np.int64)))
-    #    else:
-    #        return (DMOpRepLindblad, (self.errorgen_rep, self.mu, self.eta, self.m_star, self.s,
-    #                                  self.unitary_postfactor.data, self.unitary_postfactor.indices,
-    #                                  self.unitary_postfactor.indptr))
-
     def acton(self, state):
         """ Act this gate map on an input state """
         statedata = state.data.copy()  # must COPY because _custom... call below *modifies* "b" arg

pygsti/evotypes/densitymx_slow/statereps.py

@@ -14,7 +14,6 @@ import functools as _functools
 
 import numpy as _np
 
-from .. import basereps as _basereps
 from pygsti.baseobjs.statespace import StateSpace as _StateSpace
 from ...tools import basistools as _bt
 from ...tools import optools as _ot
@@ -25,13 +24,17 @@ except ImportError:
     _fastcalc = None
 
 
-class StateRep(_basereps.StateRep):
+class StateRep:
+    """A real superket representation of an element in Hilbert-Schmidt space."""
+
     def __init__(self, data, state_space):
         #vec = _np.asarray(vec, dtype='d')
         assert(data.dtype == _np.dtype('d'))
         self.data = _np.require(data.copy(), requirements=['OWNDATA', 'C_CONTIGUOUS'])
         self.state_space = _StateSpace.cast(state_space)
-        assert(len(self.data) == self.state_space.dim)
+        ds0 = self.data.shape[0]
+        assert(ds0 == self.state_space.dim)
+        assert(ds0 == self.data.size)
 
     def __reduce__(self):
         return (StateRep, (self.data, self.state_space), (self.data.flags.writeable,))
@@ -62,6 +65,10 @@ class StateRep(_basereps.StateRep):
 
 
 class StateRepDense(StateRep):
+    """
+    An almost-trivial wrapper around StateRep.
+    Implements the "base" property and defines a trivial "base_has_changed" function.
+    """
 
     def __init__(self, data, state_space, basis):
         #ignore basis for now (self.basis = basis in future?)

pygsti/evotypes/evotype.py

@@ -1,6 +1,7 @@
 import importlib as _importlib
 
 from . import basereps as _basereps
+from pygsti.baseobjs.statespace import StateSpace as _StateSpace
 
 
 class Evotype(object):
@@ -50,10 +51,46 @@ class Evotype(object):
     }
 
     @classmethod
-    def cast(cls, obj, default_prefer_dense_reps=False):
+    def cast(cls, obj, default_prefer_dense_reps=None, state_space=None):
+        """
+        Cast the specified object to an Evotype with options for default Evotype
+        handling.
+
+        Parameters
+        ----------
+        obj : Evotype or str
+            Object to cast to an Evotype. If already an Evotype the object is simply
+            returned. Otherwise if a string we attempt to cast it to a recognized
+            evotype option. If the string "default" is passed in then we determine
+            the type of evotype used in conjunction with the two optional kwargs below.
+
+        default_prefer_dense_reps : None or bool, optional (default None)
+            Flag to indicate preference for dense representation types when casting
+            a string. If None then there is no preference and this will be determined
+            by the optional state_space kwarg, if present. Otherwise if a boolean value
+            this selection overrides any logic based on the state space.
+
+        state_space : StateSpace, optional (default None)
+            If not None then the dimension of the state space is used to determine whether
+            or not to prefer the use of dense representation types when not already specified
+            by the default_prefer_dense_reps kwarg.
+        
+        Returns
+        -------
+        Evotype
+        """
         if isinstance(obj, Evotype):
             return obj
-        elif obj == "default":
+        
+        if default_prefer_dense_reps is None:
+            if state_space is None:
+                default_prefer_dense_reps = False #reproduces legacy behavior.
+            else:
+                if not isinstance(state_space, _StateSpace):
+                    raise ValueError('state_space must be a StateSpace object.')
+                default_prefer_dense_reps = False if state_space.dim > 64 else True #HARDCODED
+
+        if obj == "default":
             return Evotype(cls.default_evotype, default_prefer_dense_reps)
         else:  # assume obj is a string naming an evotype
             return Evotype(str(obj), default_prefer_dense_reps)

pygsti/evotypes/stabilizer/effectreps.pyx

@@ -39,10 +39,6 @@ cdef class EffectRep(_basereps_cython.EffectRep):
     def nqubits(self):
         return self.state_space.num_qubits
 
-    #@property
-    #def dim(self):
-    #    return 2**(self.c_effect._n)  # assume "unitary evolution"-type mode
-
     def probability(self, StateRep state not None):
         #unnecessary (just put in signature): cdef StateRep st = <StateRep?>state
         return self.c_effect.probability(state.c_state)

pygsti/evotypes/stabilizer/opreps.pyx

@@ -40,10 +40,6 @@ cdef class OpRep(_basereps_cython.OpRep):
     def nqubits(self):
         return self.state_space.num_qubits
 
-    #@property
-    #def dim(self):
-    #    return 2**(self.nqubits)  # assume "unitary evolution"-type mode
-
     def acton(self, StateRep state not None):
         cdef INT n = self.c_rep._n
         cdef INT namps = state.c_state._namps

pygsti/evotypes/stabilizer/statereps.pyx

@@ -49,10 +49,6 @@ cdef class StateRep(_basereps_cython.StateRep):
     def nqubits(self):
         return self.state_space.num_qubits
 
-    #@property
-    #def dim(self):
-    #    return 2**(self.c_state._n) # assume "unitary evolution"-type mode
-
     def actionable_staterep(self):
         # return a state rep that can be acted on by op reps or mapped to
         # a probability/amplitude by POVM effect reps.
@@ -129,7 +125,7 @@ cdef class StateRepTensorProduct(StateRep):
     def __cinit__(self, factor_state_reps, state_space):
         self.factor_reps = factor_state_reps
         n = sum([sf.nqubits for sf in self.factor_reps])  # total number of qubits
-        np = int(_np.product([len(sf.pvectors) for sf in self.factor_reps]))
+        np = int(_np.prod([len(sf.pvectors) for sf in self.factor_reps]))
         self._cinit_base(_np.zeros((2 * n, 2 * n), _np.int64),
                          _np.zeros((np, 2 * n), _np.int64),
                          _np.ones(np, complex),

pygsti/evotypes/stabilizer/termreps.pyx

@@ -107,10 +107,3 @@ cdef class TermRep(_basereps_cython.TermRep):
         return TermRep(self.coeff.copy(), self.magnitude, self.logmagnitude,
                          self.pre_state, self.post_state, self.pre_effect, self.post_effect,
                          self.pre_ops, self.post_ops)
-
-    #Not needed - and this implementation is quite right as it will need to change
-    # the ordering of the pre/post ops also.
-    #def conjugate(self):
-    #    return TermRep(self.coeff.copy(), self.magnitude, self.logmagnitude,
-    #                     self.post_state, self.pre_state, self.post_effect, self.pre_effect,
-    #                     self.post_ops, self.pre_ops)

pygsti/evotypes/stabilizer_slow/effectreps.py

@@ -23,10 +23,6 @@ class EffectRep(_basereps.EffectRep):
     def nqubits(self):
         return self.state_space.num_qubits
 
-    #@property
-    #def dim(self):
-    #    return 2**self.nqubits  # assume "unitary evolution"-type mode
-
     def probability(self, state):
         return state.sframe.measurement_probability(self.zvals, check=True)  # use check for now?
 
@@ -37,10 +33,6 @@ class EffectRep(_basereps.EffectRep):
         return _mt.zvals_to_dense(self.zvals, superket=bool(on_space not in ('minimal', 'Hilbert')))
 
 
-#class EffectRepConjugatedState(EffectRep):
-#    pass  # TODO - this should be possible
-
-
 class EffectRepComputational(EffectRep):
 
     def __init__(self, zvals, basis, state_space):
@@ -49,17 +41,6 @@ class EffectRepComputational(EffectRep):
         assert(self.state_space.num_qubits == len(self.zvals))
         super(EffectRepComputational, self).__init__(state_space)
 
-    #@property
-    #def outcomes(self):
-    #    """
-    #    The 0/1 outcomes identifying this effect within its StabilizerZPOVM
-    #
-    #    Returns
-    #    -------
-    #    numpy.ndarray
-    #    """
-    #    return self.zvals
-
     def __str__(self):
         nQubits = len(self.zvals)
         s = "Stabilizer effect vector for %d qubits with outcome %s" % (nQubits, str(self.zvals))
@@ -80,9 +61,6 @@ class EffectRepComposed(EffectRep):
 
         super(EffectRepComposed, self).__init__(state_space)
 
-    #def __reduce__(self):
-    #    return (EffectRepComposed, (self.op_rep, self.effect_rep, self.op_id, self.state_space))
-
     def probability(self, state):
         state = self.op_rep.acton(state)  # *not* acton_adjoint
         return self.effect_rep.probability(state)

pygsti/evotypes/stabilizer_slow/opreps.py

@@ -34,10 +34,6 @@ class OpRep(_basereps.OpRep):
     def nqubits(self):
         return self.state_space.num_qubits
 
-    #@property
-    #def dim(self):
-    #    return 2**(self.nqubits)  # assume "unitary evolution"-type mode
-
 
 class OpRepClifford(OpRep):
     def __init__(self, unitarymx, symplecticrep, basis, state_space):

pygsti/evotypes/stabilizer_slow/statereps.py

@@ -42,10 +42,6 @@ class StateRep(_basereps.StateRep):
     def nqubits(self):
         return self.sframe.n
 
-    #@property
-    #def dim(self):
-    #    return 2**self.nqubits  # assume "unitary evolution"-type mode
-
     def actionable_staterep(self):
         # return a state rep that can be acted on by op reps or mapped to
         # a probability/amplitude by POVM effect reps.

pygsti/evotypes/statevec/effectreps.pyx

@@ -111,7 +111,7 @@ cdef class EffectRepTensorProduct(EffectRep):
         cdef _np.ndarray[_np.int64_t, ndim=1, mode='c'] factor_dims = \
             _np.ascontiguousarray(_np.array([fct.state_space.udim for fct in povm_factors], _np.int64))
 
-        cdef INT dim = _np.product(factor_dims)
+        cdef INT dim = _np.prod(factor_dims)
         cdef INT nfactors = len(self.povm_factors)
         self.povm_factors = povm_factors
         self.effect_labels = effect_labels

pygsti/evotypes/statevec/opreps.pyx

@@ -246,7 +246,7 @@ cdef class OpRepEmbedded(OpRep):
         # final map just acts as identity w.r.t.
         labelIndices = [tensorProdBlkLabels.index(label) for label in target_labels]
         cdef _np.ndarray[_np.int64_t, ndim=1, mode='c'] action_inds = _np.array(labelIndices, _np.int64)
-        assert(_np.product([num_basis_els[i] for i in action_inds]) == embedded_rep.dim), \
+        assert(_np.prod([num_basis_els[i] for i in action_inds]) == embedded_rep.dim), \
             "Embedded operation has dimension (%d) inconsistent with the given target labels (%s)" % (
                 embedded_rep.dim, str(target_labels))
 
@@ -256,7 +256,7 @@ cdef class OpRepEmbedded(OpRep):
         cdef INT ncomponents_in_active_block = len(state_space.tensor_product_block_labels(active_block_index))
         cdef INT embedded_dim = embedded_rep.dim
         cdef _np.ndarray[_np.int64_t, ndim=1, mode='c'] blocksizes = \
-            _np.array([_np.product(state_space.tensor_product_block_udimensions(k))
+            _np.array([_np.prod(state_space.tensor_product_block_udimensions(k))
                        for k in range(nblocks)], _np.int64)
         cdef INT i, j
 

pygsti/evotypes/statevec/statereps.pyx

@@ -150,7 +150,7 @@ cdef class StateRepTensorProduct(StateRep):
 
     def __init__(self, factor_state_reps, state_space):
         self.factor_reps = factor_state_reps
-        dim = _np.product([fct.dim for fct in self.factor_reps])
+        dim = _np.prod([fct.dim for fct in self.factor_reps])
         self._cinit_base(_np.zeros(dim, complex), state_space, None)  # TODO: compute a tensorprod basis?
         self.reps_have_changed()
 

pygsti/evotypes/statevec/termreps.pyx

@@ -112,13 +112,6 @@ cdef class TermRep(_basereps_cython.TermRep):
                          self.pre_state, self.post_state, self.pre_effect, self.post_effect,
                          self.pre_ops, self.post_ops)
 
-    #Not needed - and this implementation is quite right as it will need to change
-    # the ordering of the pre/post ops also.
-    #def conjugate(self):
-    #    return TermRep(self.coeff.copy(), self.magnitude, self.logmagnitude,
-    #                     self.post_state, self.pre_state, self.post_effect, self.pre_effect,
-    #                     self.post_ops, self.pre_ops)
-
 
 #Note: to use direct term reps (numerical coeffs) we'll need to update
 # what the members are called and add methods as was done for TermRep.

pygsti/evotypes/statevec_slow/effectreps.py

@@ -180,9 +180,6 @@ class EffectRepComposed(EffectRep):
 
         super(EffectRepComposed, self).__init__(effect_rep.state_space)
 
-    #def __reduce__(self):
-    #    return (EffectRepComposed, (self.op_rep, self.effect_rep, self.op_id, self.state_space))
-
     def probability(self, state):
         state = self.op_rep.acton(state)  # *not* acton_adjoint
         return self.effect_rep.probability(state)

pygsti/evotypes/statevec_slow/opreps.py

@@ -107,11 +107,6 @@ class OpRepStandard(OpRepDenseUnitary):
         super(OpRepStandard, self).__init__(U, basis, state_space)
 
 
-#class OpRepStochastic(OpRepDense):
-# - maybe we could add this, but it wouldn't be a "dense" op here,
-#   perhaps we need to change API?
-
-
 class OpRepComposed(OpRep):
     # exactly the same as densitymx case
     def __init__(self, factor_op_reps, state_space):

pygsti/extras/__init__.py

@@ -9,5 +9,4 @@
 """ Container for beyond-GST sub-packages """
 
 # from . import drift
-# from . import rb  # temporarily removed until RB analysis is fixed
 # from . import rpe

pygsti/extras/drift/stabilityanalyzer.py

@@ -1235,9 +1235,11 @@ class StabilityAnalyzer(object):
 
                     # If we're not testing a single spectrum we need to flatten the >1D array.
                     if len(_np.shape(spectra)) > 1:
+                        # Use flatten (rather than ravel) to ensure a copy is made.
                         powerlist = spectra[indices].flatten()
                     # If we're testing a single spectrum, we can just copy the 1D array.
-                    else: powerlist = spectra[indices].copy()
+                    else:
+                        powerlist = spectra[indices].copy()
 
                     # The indices that will go with the elements in the flattened spectra.
                     powerindices = [tup for tup in _itertools.product(*iterBenjHoch)]

pygsti/extras/interpygate/__init__.py

@@ -10,3 +10,15 @@
 
 from .core import PhysicalProcess, InterpolatedDenseOp, InterpolatedOpFactory
 from .process_tomography import vec, unvec, run_process_tomography
+
+# Note from Riley on September, 2024:
+#
+#   vec is deprecated, and shouldn't be called anywhere in the codebase.
+#
+#   unvec is deprecated and replaced with unvec_square; the latter function
+#   isn't imported here because we don't want people to access it just from
+#   the pygsti.extras.interpygate namespace.
+#
+#   Ideally we'd remove vec and unvec from the pygsti.extras.interpygate namespace
+#   and only have them available in pygsti.extras.interpygate.process_tomography.
+#

pygsti/extras/interpygate/core.py

@@ -241,15 +241,6 @@ class InterpolatedOpFactory(_OpFactory):
         return InterpolatedDenseOp(target_op, self.base_interpolator, self.aux_interpolator, self.to_vector(),
                                    _np.array(args), self._argument_indices)
 
-    #def write(self, dirname):
-    #    dirname = _pathlib.Path(dirname)
-    #    with open(str(dirname / "targetop.pkl"), 'wb') as f:
-    #        _pickle.dump(self.target_op, f)
-    #    _np.save(dirname / "paramvec.np", self._paramvec_with_time)
-    #    self.base_interpolator.write(dirname / "base.interp")
-    #    if self.aux_interpolator is not None:
-    #        self.aux_interptolator.write(dirname / "aux.interp")
-
     @property
     def num_params(self):
         return len(self._paramvec)
@@ -267,24 +258,6 @@ class InterpolatedOpFactory(_OpFactory):
 
 class InterpolatedDenseOp(_DenseOperator):
 
-    #@classmethod
-    #def from_dir(cls, dirname):
-    #    dirname = _pathlib.Path(dirname)
-    #    with open(str(dirname / "targetop.pkl"), 'rb') as f:
-    #        target_op = _pickle.load(f)
-    #    pt = _np.load(dirname / "paramvec.np")
-    #    base_interp = InterpolatedQuantity.from_file(dirname / "base.interp")
-    #    aux_interp = InterpolatedQuantity.from_file(dirname / "aux.interp") \
-    #        if (dirname / "aux.interp").exists() else None
-    #
-    #    if base_interp.times is not None:
-    #        tm = pt[-1]
-    #        pt = pt[0:-1]
-    #    else:
-    #        tm = None
-    #
-    #    return cls(target_op, base_interp, aux_interp, pt, tm)
-
     @classmethod
     def create_by_interpolating_physical_process(cls, target_op, physical_process, parameter_ranges=None,
                                                  parameter_points=None, comm=None,
@@ -391,15 +364,6 @@ class InterpolatedDenseOp(_DenseOperator):
         # initialize object
         self.from_vector(self._paramvec)
 
-    #def write(self, dirname):
-    #    dirname = _pathlib.Path(dirname)
-    #    with open(str(dirname / "targetop.pkl"), 'wb') as f:
-    #        _pickle.dump(self.target_op, f)
-    #    _np.save(dirname / "paramvec.np", self._paramvec_with_time)
-    #    self.base_interpolator.write(dirname / "base.interp")
-    #    if self.aux_interpolator is not None:
-    #        self.aux_interptolator.write(dirname / "aux.interp")
-
     @property
     def num_params(self):
         return len(self._paramvec)