pyGSTi 0.9.12.1__cp310-cp310-win32.whl → 0.9.13__cp310-cp310-win32.whl

pygsti/forwardsims/termforwardsim_calc_statevec.pyx

@@ -1531,654 +1531,3 @@ def circuit_achieved_and_max_sopm(fwdsim, rholabel, elabels, circuit, repcache,
         max_sopm[i] = max_sum_of_pathmags[i]
 
     return achieved_sopm, max_sopm
-
-
-
-
-# State-vector direct-term calcs -------------------------
-
-#cdef vector[vector[TermDirectCRep_ptr]] extract_cterms_direct(python_termrep_lists, INT max_order):
-#    cdef vector[vector[TermDirectCRep_ptr]] ret = vector[vector[TermDirectCRep_ptr]](max_order+1)
-#    cdef vector[TermDirectCRep*] vec_of_terms
-#    for order,termreps in enumerate(python_termrep_lists): # maxorder+1 lists
-#        vec_of_terms = vector[TermDirectCRep_ptr](len(termreps))
-#        for i,termrep in enumerate(termreps):
-#            vec_of_terms[i] = (<TermDirectRep?>termrep).c_term
-#        ret[order] = vec_of_terms
-#    return ret
-
-#def prs_directly(calc, rholabel, elabels, circuit, repcache, comm=None, mem_limit=None, fastmode=True, wt_tol=0.0, reset_term_weights=True, debug=None):
-#
-#    # Create gatelable -> int mapping to be used throughout
-#    distinct_gateLabels = sorted(set(circuit))
-#    glmap = { gl: i for i,gl in enumerate(distinct_gateLabels) }
-#    t0 = pytime.time()
-#
-#    # Convert circuit to a vector of ints
-#    cdef INT i, j
-#    cdef vector[INT] cgatestring
-#    for gl in circuit:
-#        cgatestring.push_back(<INT>glmap[gl])
-#
-#    #TODO: maybe compute these weights elsewhere and pass in?
-#    cdef double circuitWeight
-#    cdef double remaingingWeightTol = <double?>wt_tol
-#    cdef vector[double] remainingWeight = vector[double](<INT>len(elabels))
-#    if 'circuitWeights' not in repcache:
-#        repcache['circuitWeights'] = {}
-#    if reset_term_weights or circuit not in repcache['circuitWeights']:
-#        circuitWeight = calc.sos.get_prep(rholabel).total_term_weight()
-#        for gl in circuit:
-#            circuitWeight *= calc.sos.get_operation(gl).total_term_weight()
-#        for i,elbl in enumerate(elabels):
-#            remainingWeight[i] = circuitWeight * calc.sos.get_effect(elbl).total_term_weight()
-#        repcache['circuitWeights'][circuit] = [ remainingWeight[i] for i in range(remainingWeight.size()) ]
-#    else:
-#        for i,wt in enumerate(repcache['circuitWeights'][circuit]):
-#            assert(wt > 1.0)
-#            remainingWeight[i] = wt
-#
-#    #if reset_term_weights:
-#    #    print "Remaining weights: "
-#    #    for i in range(remainingWeight.size()):
-#    #        print remainingWeight[i]
-#
-#    cdef double order_base = 0.1 # default for now - TODO: make this a calc param like max_order?
-#    cdef INT order
-#    cdef INT numEs = len(elabels)
-#
-#    cdef RepCacheEl repcel;
-#    cdef vector[TermDirectCRep_ptr] treps;
-#    cdef DCOMPLEX* coeffs;
-#    cdef vector[TermDirectCRep*] reps_at_order;
-#    cdef np.ndarray coeffs_array;
-#    cdef TermDirectRep rep;
-#
-#    # Construct dict of gate term reps, then *convert* to c-reps, as this
-#    #  keeps alive the non-c-reps which keep the c-reps from being deallocated...
-#    cdef unordered_map[INT, vector[vector[TermDirectCRep_ptr]] ] op_term_reps = unordered_map[INT, vector[vector[TermDirectCRep_ptr]] ](); # OLD = {}
-#    for glbl in distinct_gateLabels:
-#        if glbl in repcache:
-#            repcel = <RepCacheEl?>repcache[glbl]
-#            op_term_reps[ glmap[glbl] ] = repcel.reps
-#            for order in range(calc.max_order+1):
-#                treps = repcel.reps[order]
-#                coeffs_array = calc.sos.operation(glbl).get_direct_order_coeffs(order,order_base)
-#                coeffs = <DCOMPLEX*?>(coeffs_array.data)
-#                for i in range(treps.size()):
-#                    treps[i]._coeff = coeffs[i]
-#                    if reset_term_weights: treps[i]._magnitude = abs(coeffs[i])
-#            #for order,treps in enumerate(op_term_reps[ glmap[glbl] ]):
-#            #    for coeff,trep in zip(calc.sos.operation(glbl).get_direct_order_coeffs(order,order_base), treps):
-#            #        trep.set_coeff(coeff)
-#        else:
-#            repcel = RepCacheEl(calc.max_order)
-#            for order in range(calc.max_order+1):
-#                reps_at_order = vector[TermDirectCRep_ptr](0)
-#                for t in calc.sos.operation(glbl).get_direct_order_terms(order,order_base):
-#                    rep = (<TermDirectRep?>t.torep(None,None,"gate"))
-#                    repcel.pyterm_references.append(rep)
-#                    reps_at_order.push_back( rep.c_term )
-#                repcel.reps[order] = reps_at_order
-#            #OLD
-#            #reps = [ [t.torep(None,None,"gate") for t in calc.sos.operation(glbl).get_direct_order_terms(order,order_base)]
-#            #                                for order in range(calc.max_order+1) ]
-#            op_term_reps[ glmap[glbl] ] = repcel.reps
-#            repcache[glbl] = repcel
-#
-#    #OLD
-#    #op_term_reps = { glmap[glbl]: [ [t.torep(None,None,"gate") for t in calc.sos.operation(glbl).get_direct_order_terms(order,order_base)]
-#    #                                  for order in range(calc.max_order+1) ]
-#    #                   for glbl in distinct_gateLabels }
-#
-#    #Similar with rho_terms and E_terms
-#    cdef vector[vector[TermDirectCRep_ptr]] rho_term_reps;
-#    if rholabel in repcache:
-#        repcel = repcache[rholabel]
-#        rho_term_reps = repcel.reps
-#        for order in range(calc.max_order+1):
-#            treps = rho_term_reps[order]
-#            coeffs_array = calc.sos.prep(rholabel).get_direct_order_coeffs(order,order_base)
-#            coeffs = <DCOMPLEX*?>(coeffs_array.data)
-#            for i in range(treps.size()):
-#                treps[i]._coeff = coeffs[i]
-#                if reset_term_weights: treps[i]._magnitude = abs(coeffs[i])
-#
-#        #for order,treps in enumerate(rho_term_reps):
-#        #    for coeff,trep in zip(calc.sos.prep(rholabel).get_direct_order_coeffs(order,order_base), treps):
-#        #        trep.set_coeff(coeff)
-#    else:
-#        repcel = RepCacheEl(calc.max_order)
-#        for order in range(calc.max_order+1):
-#            reps_at_order = vector[TermDirectCRep_ptr](0)
-#            for t in calc.sos.prep(rholabel).get_direct_order_terms(order,order_base):
-#                rep = (<TermDirectRep?>t.torep(None,None,"prep"))
-#                repcel.pyterm_references.append(rep)
-#                reps_at_order.push_back( rep.c_term )
-#            repcel.reps[order] = reps_at_order
-#        rho_term_reps = repcel.reps
-#        repcache[rholabel] = repcel
-#
-#        #OLD
-#        #rho_term_reps = [ [t.torep(None,None,"prep") for t in calc.sos.prep(rholabel).get_direct_order_terms(order,order_base)]
-#        #              for order in range(calc.max_order+1) ]
-#        #repcache[rholabel] = rho_term_reps
-#
-#    #E_term_reps = []
-#    cdef vector[vector[TermDirectCRep_ptr]] E_term_reps = vector[vector[TermDirectCRep_ptr]](0);
-#    cdef TermDirectCRep_ptr cterm;
-#    e_indices = [] # TODO: upgrade to C-type?
-#    if all([ elbl in repcache for elbl in elabels]):
-#        for order in range(calc.max_order+1):
-#            reps_at_order = vector[TermDirectCRep_ptr](0) # the term reps for *all* the effect vectors
-#            cur_indices = [] # the Evec-index corresponding to each term rep
-#            for j,elbl in enumerate(elabels):
-#                repcel = <RepCacheEl?>repcache[elbl]
-#                #term_reps = [t.torep(None,None,"effect") for t in calc.sos.effect(elbl).get_direct_order_terms(order,order_base) ]
-#
-#                treps = repcel.reps[order]
-#                coeffs_array = calc.sos.effect(elbl).get_direct_order_coeffs(order,order_base)
-#                coeffs = <DCOMPLEX*?>(coeffs_array.data)
-#                for i in range(treps.size()):
-#                    treps[i]._coeff = coeffs[i]
-#                    if reset_term_weights: treps[i]._magnitude = abs(coeffs[i])
-#                    reps_at_order.push_back(treps[i])
-#                cur_indices.extend( [j]*reps_at_order.size() )
-#
-#                #OLD
-#                #term_reps = repcache[elbl][order]
-#                #for coeff,trep in zip(calc.sos.effect(elbl).get_direct_order_coeffs(order,order_base), term_reps):
-#                #    trep.set_coeff(coeff)
-#                #cur_term_reps.extend( term_reps )
-#                # cur_indices.extend( [j]*len(term_reps) )
-#
-#            E_term_reps.push_back(reps_at_order)
-#            e_indices.append( cur_indices )
-#            # E_term_reps.append( cur_term_reps )
-#
-#    else:
-#        for elbl in elabels:
-#            if elbl not in repcache: repcache[elbl] = RepCacheEl(calc.max_order) #[None]*(calc.max_order+1) # make sure there's room
-#        for order in range(calc.max_order+1):
-#            reps_at_order = vector[TermDirectCRep_ptr](0) # the term reps for *all* the effect vectors
-#            cur_indices = [] # the Evec-index corresponding to each term rep
-#            for j,elbl in enumerate(elabels):
-#                repcel = <RepCacheEl?>repcache[elbl]
-#                treps = vector[TermDirectCRep_ptr](0) # the term reps for *all* the effect vectors
-#                for t in calc.sos.effect(elbl).get_direct_order_terms(order,order_base):
-#                    rep = (<TermDirectRep?>t.torep(None,None,"effect"))
-#                    repcel.pyterm_references.append(rep)
-#                    treps.push_back( rep.c_term )
-#                    reps_at_order.push_back( rep.c_term )
-#                repcel.reps[order] = treps
-#                cur_indices.extend( [j]*treps.size() )
-#                #term_reps = [t.torep(None,None,"effect") for t in calc.sos.effect(elbl).get_direct_order_terms(order,order_base) ]
-#                #repcache[elbl][order] = term_reps
-#                #cur_term_reps.extend( term_reps )
-#                #cur_indices.extend( [j]*len(term_reps) )
-#            E_term_reps.push_back(reps_at_order)
-#            e_indices.append( cur_indices )
-#            #E_term_reps.append( cur_term_reps )
-#
-#    #convert to c-reps
-#    cdef INT gi
-#    #cdef vector[vector[TermDirectCRep_ptr]] rho_term_creps = rho_term_reps # already c-reps...
-#    #cdef vector[vector[TermDirectCRep_ptr]] E_term_creps = E_term_reps # already c-reps...
-#    #cdef unordered_map[INT, vector[vector[TermDirectCRep_ptr]]] gate_term_creps = op_term_reps # already c-reps...
-#    #cdef vector[vector[TermDirectCRep_ptr]] rho_term_creps = extract_cterms_direct(rho_term_reps,calc.max_order)
-#    #cdef vector[vector[TermDirectCRep_ptr]] E_term_creps = extract_cterms_direct(E_term_reps,calc.max_order)
-#    #for gi,termrep_lists in op_term_reps.items():
-#    #    gate_term_creps[gi] = extract_cterms_direct(termrep_lists,calc.max_order)
-#
-#    E_cindices = vector[vector[INT]](<INT>len(e_indices))
-#    for ii,inds in enumerate(e_indices):
-#        E_cindices[ii] = vector[INT](<INT>len(inds))
-#        for jj,indx in enumerate(inds):
-#            E_cindices[ii][jj] = <INT>indx
-#
-#    #Note: term calculator "dim" is the full density matrix dim
-#    stateDim = int(round(np.sqrt(calc.dim)))
-#    if debug is not None:
-#        debug['tstartup'] += pytime.time()-t0
-#        t0 = pytime.time()
-#
-#    #Call C-only function (which operates with C-representations only)
-#    cdef vector[float] debugvec = vector[float](10)
-#    debugvec[0] = 0.0
-#    cdef vector[DCOMPLEX] prs = prs_directly(
-#        cgatestring, rho_term_reps, op_term_reps, E_term_reps,
-#        #cgatestring, rho_term_creps, gate_term_creps, E_term_creps,
-#        E_cindices, numEs, calc.max_order, stateDim, <bool>fastmode, &remainingWeight, remaingingWeightTol, debugvec)
-#
-#    debug['total'] += debugvec[0]
-#    debug['t1'] += debugvec[1]
-#    debug['t2'] += debugvec[2]
-#    debug['t3'] += debugvec[3]
-#    debug['n1'] += debugvec[4]
-#    debug['n2'] += debugvec[5]
-#    debug['n3'] += debugvec[6]
-#    debug['t4'] += debugvec[7]
-#    debug['n4'] += debugvec[8]
-#    #if not all([ abs(prs[i].imag) < 1e-4 for i in range(<INT>prs.size()) ]):
-#    #    print("ERROR: prs = ",[ prs[i] for i in range(<INT>prs.size()) ])
-#    #assert(all([ abs(prs[i].imag) < 1e-6 for i in range(<INT>prs.size()) ]))
-#    return [ prs[i].real for i in range(<INT>prs.size()) ] # TODO: make this into a numpy array? - maybe pass array to fill to prs_directy above?
-#
-#
-#cdef vector[DCOMPLEX] prs_directly(
-#    vector[INT]& circuit, vector[vector[TermDirectCRep_ptr]] rho_term_reps,
-#    unordered_map[INT, vector[vector[TermDirectCRep_ptr]]] op_term_reps,
-#    vector[vector[TermDirectCRep_ptr]] E_term_reps, vector[vector[INT]] E_term_indices,
-#    INT numEs, INT max_order, INT dim, bool fastmode, vector[double]* remainingWeight, double remTol, vector[float]& debugvec):
-#
-#    #NOTE: circuit and gate_terms use *integers* as operation labels, not Label objects, to speed
-#    # lookups and avoid weird string conversion stuff with Cython
-#
-#    cdef INT N = len(circuit)
-#    cdef INT* p = <INT*>malloc((N+2) * sizeof(INT))
-#    cdef INT i,j,k,order,nTerms
-#    cdef INT gn
-#
-#    cdef INT t0 = time.clock()
-#    cdef INT t, n, nPaths; #for below
-#
-#    cdef innerloopfn_direct_ptr innerloop_fn;
-#    if fastmode:
-#        innerloop_fn = pr_directly_innerloop_savepartials
-#    else:
-#        innerloop_fn = pr_directly_innerloop
-#
-#    #extract raw data from gate_terms dictionary-of-lists for faster lookup
-#    #gate_term_prefactors = np.empty( (nOperations,max_order+1,dim,dim)
-#    #cdef unordered_map[INT, vector[vector[unordered_map[INT, complex]]]] gate_term_coeffs
-#    #cdef vector[vector[unordered_map[INT, complex]]] rho_term_coeffs
-#    #cdef vector[vector[unordered_map[INT, complex]]] E_term_coeffs
-#    #cdef vector[vector[INT]] e_indices
-#
-#    cdef vector[INT]* Einds
-#    cdef vector[vector_TermDirectCRep_ptr_ptr] factor_lists
-#
-#    assert(max_order <= 2) # only support this partitioning below (so far)
-#
-#    cdef vector[DCOMPLEX] prs = vector[DCOMPLEX](numEs)
-#
-#    for order in range(max_order+1):
-#        #print("DB: pr_as_polynomial order=",order)
-#
-#        #for p in partition_into(order, N):
-#        for i in range(N+2): p[i] = 0 # clear p
-#        factor_lists = vector[vector_TermDirectCRep_ptr_ptr](N+2)
-#
-#        if order == 0:
-#            #inner loop(p)
-#            #factor_lists = [ gate_terms[glbl][pi] for glbl,pi in zip(circuit,p) ]
-#            t = time.clock()
-#            factor_lists[0] = &rho_term_reps[p[0]]
-#            for k in range(N):
-#                gn = circuit[k]
-#                factor_lists[k+1] = &op_term_reps[circuit[k]][p[k+1]]
-#                #if factor_lists[k+1].size() == 0: continue # WHAT???
-#            factor_lists[N+1] = &E_term_reps[p[N+1]]
-#            Einds = &E_term_indices[p[N+1]]
-#
-#            #print("Part0 ",p)
-#            nPaths = innerloop_fn(factor_lists,Einds,&prs,dim,remainingWeight,0.0) #remTol) # force 0-order
-#            debugvec[1] += float(time.clock() - t)/time.CLOCKS_PER_SEC
-#            debugvec[4] += nPaths
-#
-#        elif order == 1:
-#            t = time.clock(); n=0
-#            for i in range(N+2):
-#                p[i] = 1
-#                #inner loop(p)
-#                factor_lists[0] = &rho_term_reps[p[0]]
-#                for k in range(N):
-#                    gn = circuit[k]
-#                    factor_lists[k+1] = &op_term_reps[gn][p[k+1]]
-#                    #if len(factor_lists[k+1]) == 0: continue #WHAT???
-#                factor_lists[N+1] = &E_term_reps[p[N+1]]
-#                Einds = &E_term_indices[p[N+1]]
-#
-#                #print "DB: Order1 "
-#                nPaths = innerloop_fn(factor_lists,Einds,&prs,dim,remainingWeight,0.0) #remTol) # force 1st-order
-#                p[i] = 0
-#                n += nPaths
-#            debugvec[2] += float(time.clock() - t)/time.CLOCKS_PER_SEC
-#            debugvec[5] += n
-#
-#        elif order == 2:
-#            t = time.clock(); n=0
-#            for i in range(N+2):
-#                p[i] = 2
-#                #inner loop(p)
-#                factor_lists[0] = &rho_term_reps[p[0]]
-#                for k in range(N):
-#                    gn = circuit[k]
-#                    factor_lists[k+1] = &op_term_reps[circuit[k]][p[k+1]]
-#                    #if len(factor_lists[k+1]) == 0: continue # WHAT???
-#                factor_lists[N+1] = &E_term_reps[p[N+1]]
-#                Einds = &E_term_indices[p[N+1]]
-#
-#                nPaths = innerloop_fn(factor_lists,Einds,&prs,dim,remainingWeight,remTol)
-#                p[i] = 0
-#                n += nPaths
-#
-#            debugvec[3] += float(time.clock() - t)/time.CLOCKS_PER_SEC
-#            debugvec[6] += n
-#            t = time.clock(); n=0
-#
-#            for i in range(N+2):
-#                p[i] = 1
-#                for j in range(i+1,N+2):
-#                    p[j] = 1
-#                    #inner loop(p)
-#                    factor_lists[0] = &rho_term_reps[p[0]]
-#                    for k in range(N):
-#                        gn = circuit[k]
-#                        factor_lists[k+1] = &op_term_reps[circuit[k]][p[k+1]]
-#                        #if len(factor_lists[k+1]) == 0: continue #WHAT???
-#                    factor_lists[N+1] = &E_term_reps[p[N+1]]
-#                    Einds = &E_term_indices[p[N+1]]
-#
-#                    nPaths = innerloop_fn(factor_lists,Einds,&prs,dim,remainingWeight,remTol)
-#                    p[j] = 0
-#                    n += nPaths
-#                p[i] = 0
-#            debugvec[7] += float(time.clock() - t)/time.CLOCKS_PER_SEC
-#            debugvec[8] += n
-#
-#        else:
-#            assert(False) # order > 2 not implemented yet...
-#
-#    free(p)
-#
-#    debugvec[0] += float(time.clock() - t0)/time.CLOCKS_PER_SEC
-#    return prs
-#
-#
-#
-#cdef INT pr_directly_innerloop(vector[vector_TermDirectCRep_ptr_ptr] factor_lists, vector[INT]* Einds,
-#                                   vector[DCOMPLEX]* prs, INT dim, vector[double]* remainingWeight, double remainingWeightTol):
-#    #print("DB partition = ","listlens = ",[len(fl) for fl in factor_lists])
-#
-#    cdef INT i,j,Ei
-#    cdef double complex scale, val, newval, pLeft, pRight, p
-#    cdef double wt, cwt
-#    cdef int nPaths = 0
-#
-#    cdef TermDirectCRep* factor
-#
-#    cdef INT nFactorLists = factor_lists.size() # may need to recompute this after fast-mode
-#    cdef INT* factorListLens = <INT*>malloc(nFactorLists * sizeof(INT))
-#    cdef INT last_index = nFactorLists-1
-#
-#    for i in range(nFactorLists):
-#        factorListLens[i] = factor_lists[i].size()
-#        if factorListLens[i] == 0:
-#            free(factorListLens)
-#            return 0 # nothing to loop over! - (exit before we allocate more)
-#
-#    cdef double complex coeff   # THESE are only real changes from "as_polynomial"
-#    cdef double complex result  # version of this function (where they are PolynomialCRep type)
-#
-#    cdef StateCRep *prop1 = new StateCRep(dim)
-#    cdef StateCRep *prop2 = new StateCRep(dim)
-#    cdef StateCRep *tprop
-#    cdef EffectCRep* EVec
-#
-#    cdef INT* b = <INT*>malloc(nFactorLists * sizeof(INT))
-#    for i in range(nFactorLists): b[i] = 0
-#
-#    assert(nFactorLists > 0), "Number of factor lists must be > 0!"
-#
-#    #for factors in _itertools.product(*factor_lists):
-#    while(True):
-#        final_factor_indx = b[last_index]
-#        Ei = deref(Einds)[final_factor_indx] #final "factor" index == E-vector index
-#        wt = deref(remainingWeight)[Ei]
-#        if remainingWeightTol == 0.0 or wt > remainingWeightTol: #if we need this "path"
-#            # In this loop, b holds "current" indices into factor_lists
-#            factor = deref(factor_lists[0])[b[0]] # the last factor (an Evec)
-#            coeff = factor._coeff
-#            cwt = factor._magnitude
-#
-#            for i in range(1,nFactorLists):
-#                coeff *= deref(factor_lists[i])[b[i]]._coeff
-#                cwt *= deref(factor_lists[i])[b[i]]._magnitude
-#
-#            #pLeft / "pre" sim
-#            factor = deref(factor_lists[0])[b[0]] # 0th-factor = rhoVec
-#            prop1.copy_from(factor._pre_state)
-#            for j in range(<INT>factor._pre_ops.size()):
-#                factor._pre_ops[j].acton(prop1,prop2)
-#                tprop = prop1; prop1 = prop2; prop2 = tprop
-#            for i in range(1,last_index):
-#                factor = deref(factor_lists[i])[b[i]]
-#                for j in range(<INT>factor._pre_ops.size()):
-#                    factor._pre_ops[j].acton(prop1,prop2)
-#                    tprop = prop1; prop1 = prop2; prop2 = tprop # final state in prop1
-#            factor = deref(factor_lists[last_index])[b[last_index]] # the last factor (an Evec)
-#
-#        	# can't propagate effects, so effect's post_ops are constructed to act on *state*
-#            EVec = factor._post_effect
-#            for j in range(<INT>factor._post_ops.size()):
-#                rhoVec = factor._post_ops[j].acton(prop1,prop2)
-#                tprop = prop1; prop1 = prop2; prop2 = tprop # final state in prop1
-#            pLeft = EVec.amplitude(prop1)
-#
-#            #pRight / "post" sim
-#            factor = deref(factor_lists[0])[b[0]] # 0th-factor = rhoVec
-#            prop1.copy_from(factor._post_state)
-#            for j in range(<INT>factor._post_ops.size()):
-#                factor._post_ops[j].acton(prop1,prop2)
-#                tprop = prop1; prop1 = prop2; prop2 = tprop # final state in prop1
-#            for i in range(1,last_index):
-#                factor = deref(factor_lists[i])[b[i]]
-#                for j in range(<INT>factor._post_ops.size()):
-#                    factor._post_ops[j].acton(prop1,prop2)
-#                    tprop = prop1; prop1 = prop2; prop2 = tprop # final state in prop1
-#            factor = deref(factor_lists[last_index])[b[last_index]] # the last factor (an Evec)
-#
-#            EVec = factor._pre_effect
-#            for j in range(<INT>factor._pre_ops.size()):
-#                factor._pre_ops[j].acton(prop1,prop2)
-#                tprop = prop1; prop1 = prop2; prop2 = tprop # final state in prop1
-#            pRight = EVec.amplitude(prop1).conjugate()
-#
-#            #Add result to appropriate polynomial
-#            result = coeff * pLeft * pRight
-#            deref(prs)[Ei] = deref(prs)[Ei] + result #TODO - see why += doesn't work here
-#            deref(remainingWeight)[Ei] = wt - cwt # "weight" of this path
-#            nPaths += 1 # just for debuggins
-#
-#        #increment b ~ itertools.product & update vec_index_noop = np.dot(self.multipliers, b)
-#        for i in range(nFactorLists-1,-1,-1):
-#            if b[i]+1 < factorListLens[i]:
-#                b[i] += 1
-#                break
-#            else:
-#                b[i] = 0
-#        else:
-#            break # can't increment anything - break while(True) loop
-#
-#    #Clenaup: free allocated memory
-#    del prop1
-#    del prop2
-#    free(factorListLens)
-#    free(b)
-#    return nPaths
-#
-#
-#cdef INT pr_directly_innerloop_savepartials(vector[vector_TermDirectCRep_ptr_ptr] factor_lists,
-#                                                vector[INT]* Einds, vector[DCOMPLEX]* prs, INT dim,
-#                                                vector[double]* remainingWeight, double remainingWeightTol):
-#    #print("DB partition = ","listlens = ",[len(fl) for fl in factor_lists])
-#
-#    cdef INT i,j,Ei
-#    cdef double complex scale, val, newval, pLeft, pRight, p
-#
-#    cdef INT incd
-#    cdef TermDirectCRep* factor
-#
-#    cdef INT nFactorLists = factor_lists.size() # may need to recompute this after fast-mode
-#    cdef INT* factorListLens = <INT*>malloc(nFactorLists * sizeof(INT))
-#    cdef INT last_index = nFactorLists-1
-#
-#    for i in range(nFactorLists):
-#        factorListLens[i] = factor_lists[i].size()
-#        if factorListLens[i] == 0:
-#            free(factorListLens)
-#            return 0 # nothing to loop over! (exit before we allocate anything else)
-#
-#    cdef double complex coeff
-#    cdef double complex result
-#
-#    #fast mode
-#    cdef vector[StateCRep*] leftSaved = vector[StateCRep_ptr](nFactorLists-1)  # saved[i] is state after i-th
-#    cdef vector[StateCRep*] rightSaved = vector[StateCRep_ptr](nFactorLists-1) # factor has been applied
-#    cdef vector[DCOMPLEX] coeffSaved = vector[DCOMPLEX](nFactorLists-1)
-#    cdef StateCRep *shelved = new StateCRep(dim)
-#    cdef StateCRep *prop2 = new StateCRep(dim) # prop2 is always a temporary allocated state not owned by anything else
-#    cdef StateCRep *prop1
-#    cdef StateCRep *tprop
-#    cdef EffectCRep* EVec
-#
-#    cdef INT* b = <INT*>malloc(nFactorLists * sizeof(INT))
-#    for i in range(nFactorLists): b[i] = 0
-#    assert(nFactorLists > 0), "Number of factor lists must be > 0!"
-#
-#    incd = 0
-#
-#    #Fill saved arrays with allocated states
-#    for i in range(nFactorLists-1):
-#        leftSaved[i] = new StateCRep(dim)
-#        rightSaved[i] = new StateCRep(dim)
-#
-#    #for factors in _itertools.product(*factor_lists):
-#    #for incd,fi in incd_product(*[range(len(l)) for l in factor_lists]):
-#    while(True):
-#        # In this loop, b holds "current" indices into factor_lists
-#        #print "DB: iter-product BEGIN"
-#
-#        if incd == 0: # need to re-evaluate rho vector
-#            #print "DB: re-eval at incd=0"
-#            factor = deref(factor_lists[0])[b[0]]
-#
-#            #print "DB: re-eval left"
-#            prop1 = leftSaved[0] # the final destination (prop2 is already alloc'd)
-#            prop1.copy_from(factor._pre_state)
-#            for j in range(<INT>factor._pre_ops.size()):
-#                #print "DB: re-eval left item"
-#                factor._pre_ops[j].acton(prop1,prop2)
-#                tprop = prop1; prop1 = prop2; prop2 = tprop # swap prop1 <-> prop2
-#            rhoVecL = prop1
-#            leftSaved[0] = prop1 # final state -> saved
-#            # (prop2 == the other allocated state)
-#
-#            #print "DB: re-eval right"
-#            prop1 = rightSaved[0] # the final destination (prop2 is already alloc'd)
-#            prop1.copy_from(factor._post_state)
-#            for j in range(<INT>factor._post_ops.size()):
-#                #print "DB: re-eval right item"
-#                factor._post_ops[j].acton(prop1,prop2)
-#                tprop = prop1; prop1 = prop2; prop2 = tprop # swap prop1 <-> prop2
-#            rhoVecR = prop1
-#            rightSaved[0] = prop1 # final state -> saved
-#            # (prop2 == the other allocated state)
-#
-#            #print "DB: re-eval coeff"
-#            coeff = factor._coeff
-#            coeffSaved[0] = coeff
-#            incd += 1
-#        else:
-#            #print "DB: init from incd"
-#            rhoVecL = leftSaved[incd-1]
-#            rhoVecR = rightSaved[incd-1]
-#            coeff = coeffSaved[incd-1]
-#
-#        # propagate left and right states, saving as we go
-#        for i in range(incd,last_index):
-#            #print "DB: propagate left begin"
-#            factor = deref(factor_lists[i])[b[i]]
-#            prop1 = leftSaved[i] # destination
-#            prop1.copy_from(rhoVecL) #starting state
-#            for j in range(<INT>factor._pre_ops.size()):
-#                #print "DB: propagate left item"
-#                factor._pre_ops[j].acton(prop1,prop2)
-#                tprop = prop1; prop1 = prop2; prop2 = tprop
-#            rhoVecL = prop1
-#            leftSaved[i] = prop1
-#            # (prop2 == the other allocated state)
-#
-#            #print "DB: propagate right begin"
-#            prop1 = rightSaved[i] # destination
-#            prop1.copy_from(rhoVecR) #starting state
-#            for j in range(<INT>factor._post_ops.size()):
-#                #print "DB: propagate right item"
-#                factor._post_ops[j].acton(prop1,prop2)
-#                tprop = prop1; prop1 = prop2; prop2 = tprop
-#            rhoVecR = prop1
-#            rightSaved[i] = prop1
-#            # (prop2 == the other allocated state)
-#
-#            #print "DB: propagate coeff mult"
-#            coeff *= factor._coeff
-#            coeffSaved[i] = coeff
-#
-#        # for the last index, no need to save, and need to construct
-#        # and apply effect vector
-#        prop1 = shelved # so now prop1 (and prop2) are alloc'd states
-#
-#        #print "DB: left ampl"
-#        factor = deref(factor_lists[last_index])[b[last_index]] # the last factor (an Evec)
-#        EVec = factor._post_effect
-#        prop1.copy_from(rhoVecL) # initial state (prop2 already alloc'd)
-#        for j in range(<INT>factor._post_ops.size()):
-#            factor._post_ops[j].acton(prop1,prop2)
-#            tprop = prop1; prop1 = prop2; prop2 = tprop
-#        pLeft = EVec.amplitude(prop1) # output in prop1, so this is final amplitude
-#
-#        #print "DB: right ampl"
-#        EVec = factor._pre_effect
-#        prop1.copy_from(rhoVecR)
-#        for j in range(<INT>factor._pre_ops.size()):
-#            factor._pre_ops[j].acton(prop1,prop2)
-#            tprop = prop1; prop1 = prop2; prop2 = tprop
-#        pRight = EVec.amplitude(prop1).conjugate()
-#
-#        shelved = prop1 # return prop1 to the "shelf" since we'll use prop1 for other things next
-#
-#        #print "DB: final block"
-#        #print "DB running coeff = ",dict(coeff._coeffs)
-#        #print "DB factor coeff = ",dict(factor._coeff._coeffs)
-#        result = coeff * factor._coeff
-#        #print "DB result = ",dict(result._coeffs)
-#        result *= pLeft * pRight
-#        final_factor_indx = b[last_index]
-#        Ei = deref(Einds)[final_factor_indx] #final "factor" index == E-vector index
-#        deref(prs)[Ei] += result
-#        #print "DB prs[",INT(Ei),"] = ",dict(deref(prs)[Ei]._coeffs)
-#
-#        #assert(debug < 100) #DEBUG
-#        #print "DB: end product loop"
-#
-#        #increment b ~ itertools.product & update vec_index_noop = np.dot(self.multipliers, b)
-#        for i in range(nFactorLists-1,-1,-1):
-#            if b[i]+1 < factorListLens[i]:
-#                b[i] += 1; incd = i
-#                break
-#            else:
-#                b[i] = 0
-#        else:
-#            break # can't increment anything - break while(True) loop
-#
-#    #Cleanup: free allocated memory
-#    for i in range(nFactorLists-1):
-#        del leftSaved[i]
-#        del rightSaved[i]
-#    del prop2
-#    del shelved
-#    free(factorListLens)
-#    free(b)
-#    return 0 #TODO: fix nPaths
-