コード例 #1
0
    def func(t, b):
        if not isinstance(t, ADF) and not isinstance(b, ADF):
            return expm_multiply(t*A, b)
        t,b = to_auto_diff(t), to_auto_diff(b)
        
        if not isinstance(t.x, Number) and len(t) > 1:
            raise Exception("t must be a scalar")

        At = t.x * A
        x = expm_multiply(At, b.x)

        variables = _get_variables([t,b])
        if not variables:
            return constant(x)

        Ax = A.dot(x)
        AAx = A.dot(Ax)
        lc, qc, cp = _make_derivs_dicts()

        b_derivs = {} # stores expm_multiply(At, b.d(v))
        for i,v in enumerate(variables):
            b_derivs[v] = expm_multiply(At, b.d(v))
            lc[v] = Ax * t.d(v) + b_derivs[v]

            # replace with A * exp(At) * b.dv
            b_derivs[v] = A.dot(b_derivs[v])
            qc[v] = AAx * t.d(v) * t.d(v) + Ax * t.d2(v) + 2 * t.d(v) * b_derivs[v] + expm_multiply(At, b.d2(v))

        if get_order() == 2:
            for i, v in enumerate(variables):
                for j,u in enumerate(variables):
                    if i < j:
                        cp[(v,u)] = AAx * t.d(u) * t.d(v) + Ax * t.d2c(u,v) + t.d(u) * b_derivs[v] + t.d(v) * b_derivs[u] + expm_multiply(At, b.d2c(u,v))
        return ADF(x, lc, qc, cp)
コード例 #2
0
    def get_relevant_nodes(self, pct_heat_threshold):
        """Return a list of the relevant nodes in the prior.

        Heat diffusion is applied to the prior network based on initial
        heat on nodes that are mutated according to patient statistics.
        """
        logger.info('Setting heat for relevant nodes in prior network')
        heats = np.zeros(len(self.prior_graph))
        mut_nodes = {}
        for gene_name, muts in self.norm_mutations.items():
            if muts:
                hgnc_id = get_hgnc_id(gene_name)
                node_key = 'HGNC:%s' % hgnc_id
                mut_nodes[node_key] = muts

        for idx, node in enumerate(self.prior_graph.nodes()):
            if node in mut_nodes:
                heats[idx] = mut_nodes[node]

        gamma = -0.1
        logger.info('Calculating Laplacian matrix')
        lp_mx = nx.normalized_laplacian_matrix(self.prior_graph,
                                               weight='weight')
        logger.info('Diffusing heat')
        Df = expm_multiply(gamma * lp_mx, heats)
        heat_thresh = np.percentile(Df, pct_heat_threshold)
        logger.info('Filtering to relevant nodes with heat threshold %.2f '
                    '(%s percentile)' % (heat_thresh, pct_heat_threshold))
        # Zip the nodes with their heats and sort
        node_heats = sorted(list(zip(self.prior_graph.nodes(), Df)),
                            key=lambda x: x[1], reverse=True)
        relevant_nodes = [n for n, heat in node_heats if heat >= heat_thresh]
        return relevant_nodes
コード例 #3
0
ファイル: solver.py プロジェクト: gharib85/fplanck
    def propagate_interval(self,
                           initial,
                           tf,
                           Nsteps=None,
                           dt=None,
                           normalize=True):
        """Propagate an initial probability distribution over a time interval, return time and the probability distribution at each time-step

        Arguments:
            initial      initial probability density function
            tf           stop time (inclusive)
            Nsteps       number of time-steps (specifiy Nsteps or dt)
            dt           length of time-steps (specifiy Nsteps or dt)
            normalize    if True, normalize the initial probability
        """
        p0 = initial(*self.grid)
        if normalize:
            p0 /= np.sum(p0)

        if Nsteps is not None:
            dt = tf / Nsteps
        elif dt is not None:
            Nsteps = np.ceil(tf / dt).astype(int)
        else:
            raise ValueError('specifiy either Nsteps or Nsteps')

        time = np.linspace(0, tf, Nsteps)
        pf = expm_multiply(self.master_matrix,
                           p0.flatten(),
                           start=0,
                           stop=tf,
                           num=Nsteps,
                           endpoint=True)
        return time, pf.reshape((pf.shape[0], ) + tuple(self.Ngrid))
コード例 #4
0
 def _help_bench_expm_multiply(self, A, i, j):
     n = A.shape[0]
     print('converting the sparse matrix to a dense array...')
     tm_start = time.clock()
     A_dense = A.toarray()
     tm_end = time.clock()
     print(tm_end - tm_start, ' seconds')
     print()
     print('computing full expm of the dense array...')
     tm_start = time.clock()
     A_expm = scipy.linalg.expm(A_dense)
     full_expm_entry = A_expm[i, j]
     tm_end = time.clock()
     print('expm(A)[%d, %d]:' % (i, j), full_expm_entry)
     print(tm_end - tm_start, ' seconds')
     print()
     print('computing only column', j, 'of expm of the sparse matrix...')
     tm_start = time.clock()
     v = np.zeros(n, dtype=float)
     v[j] = 1
     A_expm_col_j = expm_multiply(A, v)
     expm_col_entry = A_expm_col_j[i]
     tm_end = time.clock()
     print('expm(A)[%d, %d]:' % (i, j), expm_col_entry)
     print(tm_end - tm_start, ' seconds')
     print()
     if np.allclose(full_expm_entry, expm_col_entry):
         print('The two methods give the same answer.')
     else:
         print('!!! The two methods give different answers. !!!')
     print()
コード例 #5
0
def diag_ops_dynamics(psi_0, ham, tsteps, dt, ops):
    ops_t = []
    psi_t = psi_0

    ops_t.append(_expec_diag_ops(psi_t, ops))
    for _ in range(tsteps - 1):
        t1 = time.time()
        psi_t = expm_multiply(-1j * dt * ham, psi_t)
        t2 = time.time()
        print(t2 - t1)
        ops_t.append(_expec_diag_ops(psi_t, ops))
        t3 = time.time()
        print(t3 - t2)

    psi_t = expm_multiply(-1j * dt * ham, psi_t)
    return (np.array(ops_t).transpose(), psi_t)
コード例 #6
0
def test_ramdom_int_matrix(N=3500, ntest=10, seed=0):
    np.random.seed(seed)
    i = 0
    while (i < ntest):
        print("testing random integer matrix {}".format(i + 1))
        data_rvs = lambda n: np.random.randint(
            -100, 100, size=n, dtype=np.int8)
        A = random(N,
                   N,
                   density=np.log(N) / N,
                   data_rvs=data_rvs,
                   dtype=np.int8)
        A = A.tocsr()

        v = np.random.normal(
            0, 1, size=(N, 10)) + 1j * np.random.normal(0, 1, size=(N, 10))
        v /= np.linalg.norm(v)

        v1 = expm_multiply(-0.01j * A, v)
        v2 = expm_multiply_parallel(A, a=-0.01j, dtype=np.complex128).dot(v)

        np.testing.assert_allclose(
            v1,
            v2,
            rtol=0,
            atol=5e-15,
            err_msg='random matrix test failed, seed {:d}'.format(seed))
        i += 1
コード例 #7
0
ファイル: ModeleVertical.py プロジェクト: guyiem/radiw
    def indice_scintillation(self,pc1d):
        assert len(pc1d.shape) == 1 , " les capteurs ne sont pas 1d "
        #print(" début IS ")
        # calcul de E[ |a_j|^2 |a_l|^2 ]
        #print(" Nm : ",self.MV.Nm)
        #print(" début calcul matrice B ")
        matB = self.MV.matriceB()
        #print(" fin calcul matrice B ")
        A0,AA0 = npy.meshgrid(self.aj0,self.aj0)
        P0 = (npy.abs(A0**2)*npy.abs(AA0**2)).flatten()
        #print(" début calcul mo4 ")
        mo4 = slinalg.expm_multiply(self.xa*matB,P0)
        #print(" fin calcul mo4 ")
        # fin calcul de E[ |a_j|^2 |a_l|^2 ]

        # calcul de E[I]^2
        #print( " début calcul E[I]^2 " )
        phiJ2 = 0
        for pc in pc1d:
            phiJ2 += self.MV.modesPropagatifs(pc)**2
        espI2 = npy.sum( 1/self.MV.Kxj * phiJ2 * self.mo2 )**2
        #print( " fin calcul E[I]^2 " )
        #espI2 = npy.sum( self.mo2 )**2 
        # fin calcul de E[I]^2L

        # calcul de E[ I^2 ]
        #print( " début calcul E[I^2] " )
        BJ,BBJ = npy.meshgrid(npy.abs(self.MV.Kxj),npy.abs(self.MV.Kxj))
        BJL = (BJ*BBJ).flatten()
        PJ,PPJ = npy.meshgrid(phiJ2,phiJ2)
        termesNonCroisees = npy.eye(PJ.shape[0]).flatten()
        PJL2 = (PJ*PPJ).flatten()
        EI2 = 2* (1/BJL)*PJL2 * mo4 - termesNonCroisees*(1/BJL)*PJL2 * mo4
        return (npy.sum(EI2) - espI2) / espI2
コード例 #8
0
    def init_matrices(self):
        'initialize the one-step basis and input effects matrices'

        dims = self.dims
        Timers.tic('expm')
        self.one_step_matrix_exp = expm(self.a_csc * self.time_elapser.step_size)
        Timers.toc('expm')

        Timers.tic('toarray')
        self.one_step_matrix_exp = self.one_step_matrix_exp.toarray()
        Timers.toc('toarray')

        if self.b_csc is not None:
            self.one_step_input_effects_matrix = np.zeros(self.b_csc.shape, dtype=float)

            for c in range(self.time_elapser.inputs):
                # create the a_matrix augmented with a column of the b_matrix as an affine term
                indptr = self.b_csc.indptr

                data = np.concatenate((self.a_csc.data, self. b_csc.data[indptr[c]:indptr[c+1]]))
                indices = np.concatenate((self.a_csc.indices, self.b_csc.indices[indptr[c]:indptr[c+1]]))
                indptr = np.concatenate((self.a_csc.indptr, [len(data)]))

                aug_a_csc = csc_matrix((data, indices, indptr), shape=(dims + 1, dims + 1))

                mat = aug_a_csc * self.time_elapser.step_size

                # the last column of matrix_exp is the same as multiplying it by the initial state [0, 0, ..., 1]
                init_state = np.zeros(dims + 1, dtype=float)
                init_state[dims] = 1.0
                col = expm_multiply(mat, init_state)

                self.one_step_input_effects_matrix[:, c] = col[:dims]
コード例 #9
0
ファイル: diffusion.py プロジェクト: decarlin/diffusiond
    def start(self):
        """Diffuses the selected nodes against the network"""
        logging.info('Diffuser: Starting diffusion')

        if self.calculate_kernel:
            logging.info('Diffuser: Calculating kernel')
            self.calculateKernel(self.L)

        logging.info('Diffuser: Calculating kernel')

        if self.input_vector is not None:
            if self.calculate_kernel:
                self.out_vector = self.kernel.dot(self.input_vector)
            else:
                self.out_vector = expm_multiply(-self.L,
                                                self.input_vector,
                                                start=0,
                                                stop=0.1,
                                                endpoint=True)[-1]

            self.node_dict = dict([
                (self.network.node.keys()[i], self.out_vector[i])
                for i in range(len(self.network.node.keys()))
            ])
            sorted_diffused = sorted(self.node_dict.items(),
                                     key=operator.itemgetter(1),
                                     reverse=True)
            self.node_dict_rank = dict([(sorted_diffused[i][0], i)
                                        for i in range(len(sorted_diffused))])
            nx.set_node_attributes(self.network, 'diffused_output',
                                   self.node_dict)
            nx.set_node_attributes(self.network, 'diffused_output_rank',
                                   self.node_dict_rank)
        logging.info('Diffuser: Diffusion completed')
        return self.network
コード例 #10
0
 def _help_bench_expm_multiply(self, A, i, j):
     n = A.shape[0]
     print('converting the sparse matrix to a dense array...')
     tm_start = time.clock()
     A_dense = A.toarray()
     tm_end = time.clock()
     print(tm_end - tm_start, ' seconds')
     print()
     print('computing full expm of the dense array...')
     tm_start = time.clock()
     A_expm = scipy.linalg.expm(A_dense)
     full_expm_entry = A_expm[i, j]
     tm_end = time.clock()
     print('expm(A)[%d, %d]:' % (i, j), full_expm_entry)
     print(tm_end - tm_start, ' seconds')
     print()
     print('computing only column', j, 'of expm of the sparse matrix...')
     tm_start = time.clock()
     v = np.zeros(n, dtype=float)
     v[j] = 1
     A_expm_col_j = expm_multiply(A, v)
     expm_col_entry = A_expm_col_j[i]
     tm_end = time.clock()
     print('expm(A)[%d, %d]:' % (i, j), expm_col_entry)
     print(tm_end - tm_start, ' seconds')
     print()
     if np.allclose(full_expm_entry, expm_col_entry):
         print('The two methods give the same answer.')
     else:
         print('!!! The two methods give different answers. !!!')
     print()
コード例 #11
0
def quantum_walk_hypercube(N, timesteps, normalise=True):
    P = 2**N  # number of positions
    gamma = 1/N  # hopping rate

    A = hypercube(N)
    H = gamma * (A - N * np.eye(2 ** N))

    posn0 = np.zeros(P)
    posn0[0] = 1
    psi0 = posn0

    psiN = expm_multiply(-(1j) * timesteps * H, psi0)

    prob = np.real(np.conj(psiN) * psiN)

    result = np.zeros(N + 1)
    normalise_array = np.zeros(N + 1)

    for i, probability in enumerate(prob):
        binary_i = bin(i)
        i_ones = [ones for ones in binary_i[2:] if ones == '1']
        num_ones = len(i_ones)
        result[num_ones] += probability
        if normalise:
            normalise_array[num_ones] += 1

    if normalise:
        result = result/normalise_array

    return result
コード例 #12
0
def adiabatic(n, T, M, H_driver, H_problem, normalise=True):
    N = 2**n
    psiN = np.ones(N) * (1 / np.sqrt(N))
    H = H_driver

    prob_ground_H = np.zeros(M + 1)
    prob_ground_H[0] = np.abs(np.dot(first_eigv(H), psiN))**2

    prob_ground_H_driv = np.zeros(M + 1)
    ground_state_driv = first_eigv(H_driver)
    prob_ground_H_driv[0] = np.abs(
        np.dot(np.conjugate(ground_state_driv), psiN))**2

    prob_ground_H_prob = np.zeros(M + 1)
    ground_state_prob = first_eigv(H_problem)
    prob_ground_H_prob[0] = np.abs(
        np.dot(np.conjugate(ground_state_prob), psiN))**2

    for i in range(1, M + 1):
        t = i * (T / M)
        H = hamiltonian(t, T, H_driver, H_problem)
        # U = expm(-1j * (T / M) * H)
        # psiN = np.dot(U, psiN)
        A = -1j * (T / M) * H
        psiN = expm_multiply(A, psiN)
        prob_ground_H[i] = np.abs(np.dot(np.conjugate(first_eigv(H)), psiN))**2
        prob_ground_H_driv[i] = np.abs(
            np.dot(np.conjugate(ground_state_driv), psiN))**2
        prob_ground_H_prob[i] = np.abs(
            np.dot(np.conjugate(ground_state_prob), psiN))**2

    return prob_ground_H, prob_ground_H_driv, prob_ground_H_prob
コード例 #13
0
ファイル: Floquet.py プロジェクト: weinbe58/qspin
def _evolve_step_2(i,H,t_list,dt_list):
	
	psi0=_np.zeros((H.Ns,),dtype=_np.complex128) 
	psi0[i]=1.0

	for t,dt in zip(t_list,dt_list):
		psi0 = _sla.expm_multiply(-1j*dt*H.tocsr(t),psi0)

	return psi0
コード例 #14
0
ファイル: propagation.py プロジェクト: tongqiu-jia/nbgwas
def heat_diffusion(network, diffusion_input, t=0.1):
    network_nodes = sorted(network.nodes())
    sparse_laplacian = csc_matrix(nx.laplacian_matrix(network))
    diffused_matrix = expm_multiply(-sparse_laplacian,
                                    diffusion_input,
                                    start=0,
                                    stop=t,
                                    endpoint=True)[-1]
    return diffused_matrix
コード例 #15
0
ファイル: qaoa.py プロジェクト: timasq/Quantum
def qaoa_step(state, H, n_qubits, params):
    """Returns a result of one QAOA step
    $e^{-1j*params[1]*B}e^{1j*params[0]*H}|state>$

    Args:
    ----------
        state (array): state  
        H (array): Hamiltonian of interest
        n_qubits (int): number of qubits
        params: parameters of step

    Returns:
    ----------
        scipy sparse array: state after application of $e^{-1j*params[1]*B}e^{1j*params[0]*H}|state>$
    """
    B=B_operator(n_qubits)
    state=lasp.expm_multiply(1j*params[0]*H, state)
    return lasp.expm_multiply(-1j*params[1]*B,state)  
コード例 #16
0
    def evolve(self, state: State, time):
        if state.is_ket:
            return State(expm_multiply(-1j * time * self.hamiltonian, state),
                         is_ket=state.is_ket, IS_subspace=state.IS_subspace, code=state.code, graph=self.graph)

        else:
            exp_hamiltonian = expm(-1j * time * self.hamiltonian)
            return State(exp_hamiltonian @ state @ exp_hamiltonian.conj().T,
                         is_ket=state.is_ket, IS_subspace=state.IS_subspace, code=state.code, graph=self.graph)
コード例 #17
0
ファイル: lindblad_operators.py プロジェクト: gharib85/qsim
 def nh_evolve(self, state: State, time: float):
     """Non-hermitian time evolution."""
     if state.is_ket:
         return State(expm_multiply(-1j * time * self.nh_hamiltonian, state), is_ket=state.is_ket,
                      IS_subspace=state.IS_subspace, code=state.code, graph=self.graph)
     else:
         temp = expm(-1j * time * self.nh_hamiltonian)
         return State(temp @ state @ temp.conj().T, is_ket=state.is_ket, IS_subspace=state.IS_subspace,
                      code=state.code, graph=self.graph)
コード例 #18
0
def to_discrete_time_mat(a_mat, b_mat, dt, quick=False):
    'convert an a and b matrix to a discrete time version'

    rv_a = None
    rv_b = None

    if quick:
        if not isinstance(a_mat, np.ndarray):
            a_mat = np.array(a_mat, dtype=float)

        rv_a = np.identity(a_mat.shape[0], dtype=float) + a_mat * dt

        if b_mat is not None:
            if not isinstance(b_mat, np.ndarray):
                b_mat = np.array(b_mat, dtype=float)

            rv_b = b_mat * dt
    else:
        # first convert both to csc matrices
        a_mat = csc_matrix(a_mat, dtype=float)
        dims = a_mat.shape[0]

        rv_a = expm(a_mat * dt)

        rv_a = rv_a.toarray()

        if b_mat is not None:
            b_mat = csc_matrix(b_mat, dtype=float)

            rv_b = np.zeros(b_mat.shape, dtype=float)

            inputs = b_mat.shape[1]

            for c in range(inputs):
                # create the a_matrix augmented with a column of the b_matrix as an affine term
                indptr = b_mat.indptr

                data = np.concatenate(
                    (a_mat.data, b_mat.data[indptr[c]:indptr[c + 1]]))
                indices = np.concatenate(
                    (a_mat.indices, b_mat.indices[indptr[c]:indptr[c + 1]]))
                indptr = np.concatenate((a_mat.indptr, [len(data)]))

                aug_a_csc = csc_matrix((data, indices, indptr),
                                       shape=(dims + 1, dims + 1))

                mat = aug_a_csc * dt

                # the last column of matrix_exp is the same as multiplying it by the initial state [0, 0, ..., 1]
                init_state = np.zeros(dims + 1, dtype=float)
                init_state[dims] = 1.0

                col = expm_multiply(mat, init_state)

                rv_b[:, c] = col[:dims]

    return rv_a, rv_b
コード例 #19
0
ファイル: entropy.py プロジェクト: 1119group/helloworld
def plot_entropy_time_evo_lin(spin, N, h, c, phi, start_time,
                              end_start, points):
    """
    This function plots the time evolution of von Neuman entropy over a
    linear time axis.

    Args: "spin" is the spin of the individual particles
    "N" is the system size
    "h" is the strength of the pseudo-random field
    "c" is the angular frequency of the field
    "phi" is the phase shift
    "start_time" is the first point in the plot, in time
    "end_start" is the last point in the plot, in time
    "points" is the number points to plot
    Returns: "imbalance_plot" is a list of values to be plotted.
    "error" is the status of the state choosing function that
    is called from this function. If "error" is True, then no
    state of a zero total <Sz> with an energy density could be found
    for the current configuration.
    """
    D = int(2 * spin + 1) ** N
    Sx, Sy, Sz = qm.init(spin)
    entropy_plot = np.zeros(points)
    delta_t = (end_start - start_time) / (points - 1)

    # The spin 0 block of H
    H = aubryH.blk_full(N, h, c, 0, phi).tocsc()
    E, V = np.linalg.eigh(H.toarray())
    psi, error = aubryC.get_state_blk(H, N)
    # psi = psi.toarray()

    if not error:
        # Plot the first point which requires a special kind of time evolution.
        psi = expm_multiply(-1j * H * start_time, psi)
        # psi = aubryC.time_evo_exact_diag(E, V, psi, start_time)
        # psi = lil_matrix(psi)
        # psi in the full spin basis
        psi_long = aubryC.recast(N, psi)
        psi_tz = aubryC.spin2z(D, N, psi_long)      # psi in the total Sz basis
        entropy_plot[0] += qm.get_vn_entropy(psi_tz, spin, N, mode='eqsplit')

        U = expm(-1j * H * delta_t)
        psi_time_evolved = psi
        # Plot the rest of the points.
        for plot_point in range(1, points):
            psi_time_evolved = U * psi_time_evolved
            # psi_time_evolved = aubryC.time_evo_exact_diag(E, V, psi_time_evolved ,delta_t)
            # psi_time_evolved = lil_matrix(psi_time_evolved)
            # Rewrite the time evolved state in the total Sz basis
            #  before passing it onto the entropy function.
            psi_tevo_long = aubryC.recast(N, psi_time_evolved)
            psi_time_evolved_tz = aubryC.spin2z(D, N, psi_tevo_long)
            entropy_plot[plot_point] = qm.get_vn_entropy(psi_time_evolved_tz,
                                                         spin, N,
                                                         mode='eqsplit')
    return entropy_plot, error
コード例 #20
0
ファイル: exp_ops.py プロジェクト: JonathonMisiewicz/qforte
def apply_time_evolution_op(qc, Hcsc, tn, nstates):

    qc_vec = np.array(qc.get_coeff_vec())

    return expm_multiply(Hcsc,
                         qc_vec,
                         start=0.0,
                         stop=tn,
                         num=nstates,
                         endpoint=True)
コード例 #21
0
 def time_expm_multiply(self, format):
     if format == 'full':
         # computing full expm of the dense array...
         A_expm = scipy.linalg.expm(self.A_dense)
         A_expm[self.i, self.j]
     else:
         # computing only column', j, 'of expm of the sparse matrix...
         v = np.zeros(self.n, dtype=float)
         v[self.j] = 1
         A_expm_col_j = expm_multiply(self.A, v)
         A_expm_col_j[self.i]
コード例 #22
0
 def time_expm_multiply(self, format):
     if format == 'full':
         # computing full expm of the dense array...
         A_expm = scipy.linalg.expm(self.A_dense)
         A_expm[self.i, self.j]
     else:
         # computing only column', j, 'of expm of the sparse matrix...
         v = np.zeros(self.n, dtype=float)
         v[self.j] = 1
         A_expm_col_j = expm_multiply(self.A, v)
         A_expm_col_j[self.i]
コード例 #23
0
ファイル: Floquet.py プロジェクト: ssthurai/QuSpin
def _evolve_step_2(i,H,t_list,dt_list):
	"""This function calculates the evolved state for Periodic Step (point 2. in def of 'evo_dict'. 
	
	"""
	
	psi0=_np.zeros((H.Ns,),dtype=_np.complex128) 
	psi0[i]=1.0

	for t,dt in zip(t_list,dt_list):
		psi0 = _sla.expm_multiply(-1j*dt*H.tocsr(t),psi0)

	return psi0
コード例 #24
0
ファイル: Floquet.py プロジェクト: weinbe58/qspin
def _evolve_step_1(i,H_list,dt_list):
	"""
	This function calculates the evolved state 
	"""
	
	psi0=_np.zeros((H_list[0].Ns,),dtype=_np.complex128) 
	psi0[i]=1.0

	for dt,H in zip(dt_list,H_list):
		psi0 = _sla.expm_multiply(-1j*dt*H.tocsr(),psi0)

	return psi0
コード例 #25
0
ファイル: Floquet.py プロジェクト: ssthurai/QuSpin
def _evolve_step_3(i,H_list,dt_list):
	"""This function calculates the evolved state for Periodic Step (point 3. in def of 'evo_dict'). 
	
	"""
	
	psi0=_np.zeros((H_list[0].Ns,),dtype=_np.complex128) 
	psi0[i]=1.0

	for dt,H in zip(dt_list,H_list):
		psi0 = _sla.expm_multiply(-1j*dt*H.tocsr(),psi0)

	return psi0
コード例 #26
0
    def compare_with_scipy(self, A, v, t):
        start = timer()
        result = expmv(t, A, v)
        end = timer()
        print("Expokit: {:.4f}".format(end - start))

        start = timer()
        scipy_result = expm_multiply(t * A, v)
        end = timer()
        print("expm_multiply: {:.4f}".format(end - start))

        np.testing.assert_allclose(result, scipy_result)
コード例 #27
0
ファイル: network.py プロジェクト: shfong/DiseaseScope
def heat_diffusion(heat, laplacian, start=0, end=0.1):
    """Heat diffusion 
    Iterative matrix multiplication between the graph laplacian and heat
    """

    out_vector = expm_multiply(-laplacian,
                               heat,
                               start=start,
                               stop=end,
                               endpoint=True)[-1]

    return out_vector
コード例 #28
0
    def _diffuse(self, matrix, heat_array, time):
        """

        :param matrix:
        :param heat_array:
        :param time:
        :return:
        """
        return expm_multiply(-matrix,
                             heat_array,
                             start=0,
                             stop=time,
                             endpoint=True)[-1]
コード例 #29
0
def plot_entropy():
    entropy_plot = np.zeros(sample_size)
    init_delta_t,r = get_init_delta_t(time_range_lower_lim,
                        time_range_upper_lim,sample_size)
    H,E,psi = get_random_state(Sx,Sy,Sz,spin,N,h,mode='expm')
    
    # Plot the first point which does not require time evolution.
    entropy_plot[0] += get_vn_entropy(psi,spin,N,mode='eqsplit')

    # Plot the second point which requires the first time evolution.
    current_delta_t = init_delta_t
    psi_time_evolved = expm_multiply(-1j*H*current_delta_t,psi)
    entropy_plot[1] += get_vn_entropy(psi_time_evolved,
                                spin,N,mode='eqsplit')

    # Plot the rest of the points with time evolution.
    for plot_point in range(2,sample_size):
        delta_delta_t = get_delta_delta_t(time_range_lower_lim,plot_point,r)
        current_delta_t += delta_delta_t
        psi_time_evolved = expm_multiply(-1j*H*current_delta_t,
                                psi_time_evolved)
        entropy_plot[plot_point] += get_vn_entropy(psi_time_evolved,
                                        spin,N,mode='eqsplit')
    return entropy_plot
コード例 #30
0
def adiabatic(n, T, M, H_driver, H_problem, ground_state_prob, normalise=True, sprs=True):
    N = 2**n
    psiN = np.ones(N) * (1 / np.sqrt(N))
    H = H_driver

    for i in range(1, M + 1):
        t = i * (T / M)
        H = hamiltonian(t, T, H_driver, H_problem)
        if sprs:
            A = -1j * (T / M) * H
            psiN = expm_multiply(A, psiN)
        else:
            U = expm(-1j * (T / M) * H)
            psiN = np.dot(U, psiN)

    return np.abs(np.dot(np.conjugate(ground_state_prob), psiN)) ** 2
コード例 #31
0
def both_ops_dynamics(psi_0, ham, tsteps, dt, dops, mops):
    dops_t = []
    mops_t = []
    psi_t = psi_0

    dops_t.append(_expec_diag_ops(psi_t, dops))
    mops_t.append(_expec_ops(psi_t, mops))
    for _ in range(tsteps - 1):
        t1 = time.time()
        psi_t = expm_multiply(-1j * dt * ham, psi_t)
        t2 = time.time()
        print(t2 - t1)
        dops_t.append(_expec_diag_ops(psi_t, dops))
        mops_t.append(_expec_ops(psi_t, mops))
        t3 = time.time()
        print(t3 - t2)

    return (np.array(dops_t).transpose(), np.array(mops_t).transpose())
コード例 #32
0
ファイル: solver.py プロジェクト: gharib85/fplanck
    def propagate(self, initial, time, normalize=True, dense=False):
        """Propagate an initial probability distribution in time

        Arguments:
            initial      initial probability density function
            time         amount of time to propagate
            normalize    if True, normalize the initial probability
            dense        if True, use dense method of expm (might be faster, at memory cost)
        """
        p0 = initial(*self.grid)
        if normalize:
            p0 /= np.sum(p0)

        if dense:
            pf = expm(self.master_matrix * time) @ p0.flatten()
        else:
            pf = expm_multiply(self.master_matrix * time, p0.flatten())

        return pf.reshape(self.Ngrid)
コード例 #33
0
    def edint(self, T):
        """edint: exact diagonalisation
        """
        H = self.H
        psi_0 = self.mps.recombine().reshape(-1)
        H = sum([n_body(a, i, len(H), d=2)
                 for i, a in enumerate(H)], axis=0) if not self.fullH else H
        psi_n = psi_0
        self.ed_history = [psi_0]
        dt = T[1]-T[0]
        for t in tqdm(T[:-1]):
            psi_n = expm_multiply(-1j * H*dt, psi_n)
            self.ed_history.append(psi_n)

        self.ed_history = array(self.ed_history)
        self.psi = self.ed_history[-1]
        self.mps = fMPS().left_from_state(
            self.psi.reshape([self.mps.d]*self.mps.L))
        return self
コード例 #34
0
def quantum_walk_hypercube(N, H, psi0, timesteps, normalise):
    psiN = expm_multiply(-(1j) * timesteps * H, psi0)

    prob = np.real(np.conj(psiN) * psiN)

    result = np.zeros(N + 1)
    normalise_array = np.zeros(N + 1)

    for i, probability in enumerate(prob):
        binary_i = bin(i)
        i_ones = [ones for ones in binary_i[2:] if ones == '1']
        num_ones = len(i_ones)
        result[num_ones] += probability
        if normalise:
            normalise_array[num_ones] += 1

    if normalise:
        result = result / normalise_array

    return result
コード例 #35
0
def time_evolution(psi_0, H_ev, **args):

    print('evolution')

    DIM_H = args.get("DIM_H")
    dt = args.get("dt")
    step_num = args.get("step_num")
    t_start = args.get("t_start")

    psi0 = psi_0[:, 0]

    if isinstance(H_ev, sp.sparse.csc.csc_matrix):

        HT = -1j * dt * H_ev
        psit = linalgS.expm_multiply(HT,
                                     psi0,
                                     start=0,
                                     stop=dt * step_num,
                                     num=step_num + 1,
                                     endpoint=True)

    else:

        print('denso')

        psit = np.zeros((step_num, DIM_H), dtype=np.complex)

        HT = np.asarray(-t_start * 1j * H_ev)
        mat_exp = sp.linalg.expm(HT)

        phi = psi0.dot(mat_exp.T)

        HT = np.asarray(-1j * dt * H_ev)
        mat_exp = sp.linalg.expm(HT)

        for tt in range(0, step_num):

            psit[tt] = phi
            phi = phi.dot(mat_exp.T)

    return psit
コード例 #36
0
def test_imag_time(L=20, seed=0):
    np.random.seed(seed)

    basis = spin_basis_1d(L, m=0, kblock=0, pblock=1, zblock=1)

    J = [[1.0, i, (i + 1) % L] for i in range(L)]
    static = [["xx", J], ["yy", J], ["zz", J]]
    H = hamiltonian(static, [], basis=basis, dtype=np.float64)

    (E, ), psi_gs = H.eigsh(k=1, which="SA")

    psi_gs = psi_gs.ravel()

    A = -(H.tocsr() - E * eye(H.Ns, format="csr", dtype=np.float64))

    U = expm_multiply_parallel(A)

    v1 = np.random.normal(0, 1, size=(H.Ns, 10))
    v1 /= np.linalg.norm(v1, axis=0)

    v2 = v1.copy()

    for i in range(100):
        v2 = U.dot(v2)
        v2 /= np.linalg.norm(v2)

        v1 = expm_multiply(A, v1)
        v1 /= np.linalg.norm(v1)

        if (np.all(np.abs(H.expt_value(v2) - E) < 1e-15)):
            break  #

        i += 1

    np.testing.assert_allclose(
        v1,
        v2,
        rtol=0,
        atol=5e-15,
        err_msg='imaginary time test failed, seed {:d}'.format(seed))
コード例 #37
0
ファイル: ionmap.py プロジェクト: earnric/modules
 def timeseries(self,
                ions = None,
                start=None, stop=None, num=None, endpoint=None,
                **kwargs):
     # this is TOO inefficient except for small isotope vectors
     # use of identity matrix is not a good choice.
     silent = kwargs.get('silent', False)
     self.setup_logger(silent = silent)
     kwm = dict(start=start, stop=stop, num=num, endpoint=endpoint)
     kw = kwargs.copy()
     from scipy.sparse.linalg import expm_multiply
     _a = self.map
     x = expm_multiply(
         self.a0,
         np.identity(self.a0.shape[0]),
         **kwm)
     out = []
     for a in x:
         self._project(a)
         out += [self.__call__(ions)]
     self.map = _a
     self.close_logger(timing = 'time series completed in {}.')
     return out
コード例 #38
0
ファイル: solve.py プロジェクト: Roger-luo/AdiaQC
def ExpPert(nQubits, hz, hzz, hx, Psi, T, dt, errchk, eps, outinfo):
    """ 
    Solve using exponential perturbation theory (i.e. Magnus expansion).
    """

    if outinfo['eigdat'] or outinfo['eigplot']:
        eigspec = []
    if outinfo['overlapdat'] or outinfo['overlapplot']:
        overlap = []

    N = T/dt # steps
    mingap = None

    # Loop over time
    for i in range(0, int(sp.floor(N))):
        t = i*dt
        t0 = (i-1)*dt

        # Approximate Hamiltonian to first term in Magnus expansion
        cz = (t**2 - t0**2)/(2*T)
        cx = (2*T*(t - t0) + t0**2 - t**2)/(2*T)
        Psi = sla.expm_multiply(-1j*(cx*hx + cz*(hz + hzz)), Psi)
        # This is a HUGE performance loss -- requires sparse to dense
        # A = sla.expm(-1j*(cx*hx + cz*(hz + hzz)))
        # Psi = A*Psi

        # Get eigendecomposition of true Hamiltonian if necessary
        if (errchk or outinfo['mingap']
            or outinfo['eigdat'] or outinfo['eigplot']
            or outinfo['fiddat'] or outinfo['fidplot']):
            # Unfortunately we cannot compute all eigenpairs
            if outinfo['eignum'] == 2**nQubits:
                # This is very expensive!!
                Hvals, Hvecs = sp.linalg.eigh((cx*hx + cz*(hz + hzz)).todense())
            else:
                Hvals, Hvecs = sla.eigsh(cx*hx + cz*(hz + hzz), 
                                         k=outinfo['eignum'],
                                         which='SA')
            # Sort by eigenvalues
            idx = Hvals.argsort()
            Hvals = Hvals[idx]/dt
            Hvecs = Hvecs[:,idx]

            if mingap is None:
                mingap = [sp.absolute(Hvals[1] - Hvals[0]), t/T]
            elif mingap[0] > sp.absolute(Hvals[1] - Hvals[0]):
                mingap = [sp.absolute(Hvals[1] - Hvals[0]), t/T]

        # Check for numerical error
        if (errchk):
            CheckNorm(t, nQubits, Psi, Hvecs, eps)

        # Construct eigenspectrum datapoint = [t, eigval 1, ... , eigval n]
        if (outinfo['eigdat'] or outinfo['eigplot']):
            eigspec.append(output.ConstructEigData(t, Hvals, outinfo['eignum']))

        if (outinfo['overlapdat'] or outinfo['overlapplot']):
            overlap.append(output.ConstructOverlapData(t, Psi, Hvecs[:,0]))

        # Output our progress, if specified
        if outinfo['progressout']:
            output.ProgressOutput(t, T, outinfo['outdir'])

        # Output the overlap with pattern vectors
        if outinfo['stateoverlap'] is not None:
            output.StateOverlapOutput(t, outinfo, Psi)

    # Output stuff as needed
    if (outinfo['eigdat']): 
        output.RecordEigSpec(eigspec, outinfo['outdir'], outinfo['binary'])
    if (outinfo['eigplot']):
        output.PlotEigSpec(eigspec, outinfo['outdir'], T)
    if (outinfo['overlapdat']): 
        output.RecordOverlap(overlap, outinfo['outdir'], T, outinfo['binary'])
    if (outinfo['overlapplot']): 
        output.PlotOverlap(overlap, outinfo['outdir'], T)
    if outinfo['stateoverlap'] is not None:
        output.StateOverlapLabelsOutput(t, outinfo)

    return Psi, mingap
コード例 #39
0
ファイル: mbl.py プロジェクト: 1119group/helloworld
def entropy_exp(spin,N,psi_0,H,t):
    '''Using exponentiated Hamiltonian.'''
    psi = expm_multiply(-1j*H*t,psi_0)
    entropy = get_vn_entropy(psi,spin,N,mode='eqsplit')
    return entropy
コード例 #40
0
        f.write(str(err)+'\n')


print("Done messing around, now for time-dependence:\n")


#groundState = vecs[:, 0]
#position = 32-4-(L/2-1)
#groundState = groundState[:position]+'1'+state[(position+1):]
#for i in range(0, N):
#    state = format(i, '032b')
#    if state[32-4-(L/2-1)]=='0':
#        groundState[i] = 0
groundState = np.full((N), 1.0)
groundState = groundState/(np.linalg.norm(groundState, 1))
stateTimeSeries = la.expm_multiply(cscRateMatrix, groundState, start=0.0, num=numTimeSlices, stop=totTime, endpoint=True)
densTimeSeries = cscDensityMatrix.dot(np.transpose(stateTimeSeries))
entropySeries = []
with open(resultsPlace+'timeSeries.dat', 'w') as f:
    for i in range(0, numTimeSlices):
#        entropy = 0.0
#        entropySeries.append(entropy)
        for j in range(0, L+4):
            f.write(str(totTime*float(i)/(numTimeSlices-1.0))+" "+str(j)+" "+str(np.real(densTimeSeries[j][i]))+"\n")
        entropySeries.append(st.entropy(pk=stateTimeSeries[:, i], base=2.0))
        print("Done step "+str(i+1))

with open(resultsPlace+'entropySeries.dat', 'w') as f:
    for i in entropySeries:
        f.write(str(i)+'\n')
コード例 #41
0
 def time_expm_multiply(self):
     # computing only column', j, 'of expm of the sparse matrix
     v = np.zeros(self.n, dtype=float)
     v[self.j] = 1
     A_expm_col_j = expm_multiply(self.A, v)
     A_expm_col_j[self.i]
コード例 #42
0
ファイル: entropy.py プロジェクト: 1119group/helloworld
def plot_entropy_time_evo_log(spin, N, h, c, phi, start_time,
                              end_start, points):
    """
    This function plots the time evolution of von Neuman entropy over a
    logarithmic time axis.

    Args: "spin" is the spin of the individual particles
          "N" is the system size
          "h" is the strength of the pseudo-random field
          "c" is the angular frequency of the field
          "phi" is the phase shift
          "start_time" is the first point in the plot, in time
          "end_start" is the last point in the plot, in time
          "points" is the number points to plot
    Returns: "imbalance_plot" is a list of values to be plotted.
             "error" is the status of the state choosing function that
             is called from this function. If "error" is True, then no
             state of a zero total <Sz> with an energy density could be found
             for the current configuration.
    """
    D = int(2 * spin + 1) ** N
    Sx, Sy, Sz = qm.init(spin)
    entropy_plot = np.zeros(points)
    init_delta_t, r = qm.get_init_delta_t(start_time,
                                          end_start, points)
    # The spin 0 block of H
    H = aubryH.blk_full(N, h, c, 0, phi).tocsc()
    # Use exact diagonalization for small systems.
    psi, error = aubryC.get_state_blk(H, N)
    dense = False
    if H.get_shape()[0] <= 16:
        dense = True
        H = H.toarray()
        E, V = np.linalg.eigh(H)
        tm = aubryC.time_machine(E, V, psi)

    if not error:
        # Plot the first point which requires a different kind of time
        #  evolution.

        if H.get_shape()[0] <= 16:
            psi_tevo_short = tm.evolve(start_time)
        else:
            psi_tevo_short = expm_multiply(-1j * H * start_time, psi)
        psi_long = aubryC.recast(N, psi_tevo_short)
        psi_tz = aubryC.spin2z(D, N, psi_long)   # psi in the total Sz basis
        entropy_plot[0] += qm.get_vn_entropy(psi_tz, spin, N, mode='eqsplit')

        # Plot the rest of the points with time evolution.
        for plot_point in range(1, points):
            if plot_point == 1:
                current_delta_t, r = qm.get_init_delta_t(start_time,
                                                         end_start,
                                                         points)
            elif plot_point > 1:
                delta_delta_t = qm.get_delta_delta_t(start_time,
                                                     plot_point, r)
                current_delta_t += delta_delta_t

            if dense:
                psi_tevo_short = tm.evolve(current_delta_t)
            else:
                psi_tevo_short = expm_multiply(-1j * H * current_delta_t,
                                               psi_tevo_short)
            psi_tevo_long = aubryC.recast(N, psi_tevo_short)
            psi_tevo_tz = aubryC.spin2z(D, N, psi_tevo_long)
            entropy_plot[plot_point] += qm.get_vn_entropy(psi_tevo_tz,
                                                          spin, N,
                                                          mode='eqsplit')
    return entropy_plot, error
コード例 #43
0
ファイル: moran_model.py プロジェクト: terhorst/momi
def moran_action(t, v):
    return expm_multiply(rate_matrix(len(v) - 1) * t, v)