Python random_objects.rand_herm函数代码示例

def test_CheckMulType():
    "Qobj multiplication type"

    # ket-bra and bra-ket multiplication
    psi = basis(5)
    dm = psi * psi.dag()
    assert_(dm.isoper)
    assert_(dm.isherm)

    nrm = psi.dag() * psi
    assert_equal(np.prod(nrm.shape), 1)
    assert_((abs(nrm) == 1)[0, 0])

    # operator-operator multiplication
    H1 = rand_herm(3)
    H2 = rand_herm(3)
    out = H1 * H2
    assert_(out.isoper)
    out = H1 * H1
    assert_(out.isoper)
    assert_(out.isherm)
    out = H2 * H2
    assert_(out.isoper)
    assert_(out.isherm)

    U = rand_unitary(5)
    out = U.dag() * U
    assert_(out.isoper)
    assert_(out.isherm)

    N = num(5)

    out = N * N
    assert_(out.isoper)
    assert_(out.isherm)

    # operator-ket and bra-operator multiplication
    op = sigmax()
    ket1 = basis(2)
    ket2 = op * ket1
    assert_(ket2.isket)

    bra1 = basis(2).dag()
    bra2 = bra1 * op
    assert_(bra2.isbra)

    assert_(bra2.dag() == ket2)

    # superoperator-operket and operbra-superoperator multiplication
    sop = to_super(sigmax())
    opket1 = operator_to_vector(fock_dm(2))
    opket2 = sop * opket1
    assert(opket2.isoperket)

    opbra1 = operator_to_vector(fock_dm(2)).dag()
    opbra2 = opbra1 * sop
    assert(opbra2.isoperbra)

    assert_(opbra2.dag() == opket2)

def test_zcsr_isherm():
    "spmath: zcsr_isherm"
    N = 100
    for kk in range(100):
        A = rand_herm(N, 0.1)
        B = rand_herm(N, 0.05) + 1j*rand_herm(N, 0.05)
        assert_(zcsr_isherm(A.data))
        assert_(zcsr_isherm(B.data)==0)

def test_csr_kron():
    "spmath: zcsr_kron"
    for kk in range(10):
        ra = np.random.randint(2,100)
        rb = np.random.randint(2,100)
        A = rand_herm(ra,0.5).data
        B = rand_herm(rb,0.5).data
        As = A.tocsr(1)
        Bs = B.tocsr(1)
        C = sp.kron(As,Bs, format='csr')
        D = zcsr_kron(A, B)
        assert_almost_equal(C.data, D.data)
        assert_equal(C.indices, D.indices)
        assert_equal(C.indptr, D.indptr)
        
    for kk in range(10):
        ra = np.random.randint(2,100)
        rb = np.random.randint(2,100)
        A = rand_ket(ra,0.5).data
        B = rand_herm(rb,0.5).data
        As = A.tocsr(1)
        Bs = B.tocsr(1)
        C = sp.kron(As,Bs, format='csr')
        D = zcsr_kron(A, B)
        assert_almost_equal(C.data, D.data)
        assert_equal(C.indices, D.indices)
        assert_equal(C.indptr, D.indptr)
    
    for kk in range(10):
        ra = np.random.randint(2,100)
        rb = np.random.randint(2,100)
        A = rand_dm(ra,0.5).data
        B = rand_herm(rb,0.5).data
        As = A.tocsr(1)
        Bs = B.tocsr(1)
        C = sp.kron(As,Bs, format='csr')
        D = zcsr_kron(A, B)
        assert_almost_equal(C.data, D.data)
        assert_equal(C.indices, D.indices)
        assert_equal(C.indptr, D.indptr)
        
    for kk in range(10):
        ra = np.random.randint(2,100)
        rb = np.random.randint(2,100)
        A = rand_ket(ra,0.5).data
        B = rand_ket(rb,0.5).data
        As = A.tocsr(1)
        Bs = B.tocsr(1)
        C = sp.kron(As,Bs, format='csr')
        D = zcsr_kron(A, B)
        assert_almost_equal(C.data, D.data)
        assert_equal(C.indices, D.indices)
        assert_equal(C.indptr, D.indptr)

def test_csr_kron():
    "Sparse: Test CSR Kron"
    for kk in range(10):
        ra = np.random.randint(2,100)
        rb = np.random.randint(2,100)
        A = rand_herm(ra,0.5).data
        B = rand_herm(rb,0.5).data
        C = sp.kron(A,B, format='csr')
        D = _csr_kron(A.data,A.indices,A.indptr, A.shape[0], A.shape[1],
                    B.data,B.indices,B.indptr, B.shape[0], B.shape[1])
        assert_equal(C.data, D.data)
        assert_equal(C.indices, D.indices)
        assert_equal(C.indptr, D.indptr)
        
    for kk in range(10):
        ra = np.random.randint(2,100)
        rb = np.random.randint(2,100)
        A = rand_ket(ra,0.5).data
        B = rand_herm(rb,0.5).data
        C = sp.kron(A,B, format='csr')
        D = _csr_kron(A.data,A.indices,A.indptr, A.shape[0], A.shape[1],
                    B.data,B.indices,B.indptr, B.shape[0], B.shape[1])
        assert_equal(C.data, D.data)
        assert_equal(C.indices, D.indices)
        assert_equal(C.indptr, D.indptr)
    
    for kk in range(10):
        ra = np.random.randint(2,100)
        rb = np.random.randint(2,100)
        A = rand_dm(ra,0.5).data
        B = rand_herm(rb,0.5).data
        C = sp.kron(A,B, format='csr')
        D = _csr_kron(A.data,A.indices,A.indptr, A.shape[0], A.shape[1],
                    B.data,B.indices,B.indptr, B.shape[0], B.shape[1])
        assert_equal(C.data, D.data)
        assert_equal(C.indices, D.indices)
        assert_equal(C.indptr, D.indptr)
        
    for kk in range(10):
        ra = np.random.randint(2,100)
        rb = np.random.randint(2,100)
        A = rand_ket(ra,0.5).data
        B = rand_ket(rb,0.5).data
        C = sp.kron(A,B, format='csr')
        D = _csr_kron(A.data,A.indices,A.indptr, A.shape[0], A.shape[1],
                    B.data,B.indices,B.indptr, B.shape[0], B.shape[1])
        assert_equal(C.data, D.data)
        assert_equal(C.indices, D.indices)
        assert_equal(C.indptr, D.indptr)

def test_Qobj_Spmv():
    "Qobj mult ndarray right"
    A = rand_herm(5)
    b = rand_ket(5).full()
    C = A*b
    D = A.full().dot(b)
    assert_(np.all((C-D)<1e-14))

def test_fast_sparse_basic():
    "fastsparse: fast_csr_matrix operations"
    H = rand_herm(5).data
    assert_(isinstance(H, fast_csr_matrix))
    Hadd = H + H
    assert_(isinstance(Hadd, fast_csr_matrix))
    Hsub = H + H
    assert_(isinstance(Hsub, fast_csr_matrix))
    Hmult = H * H
    assert_(isinstance(Hmult, fast_csr_matrix))
    Hcopy = H.copy()
    assert_(isinstance(Hcopy, fast_csr_matrix))
    assert_(isinstance(-1*H, fast_csr_matrix))
    assert(isinstance(H/2., fast_csr_matrix))
    
    G = sp.csr_matrix((H.data, H.indices,H.indptr), 
            copy=True, shape=H.shape)
    assert_(not isinstance(G, fast_csr_matrix))
    Hadd = H + G
    assert_(not isinstance(Hadd, fast_csr_matrix))
    Hadd = G + H
    assert_(not isinstance(Hadd, fast_csr_matrix))
    Hsub = H - G
    assert_(not isinstance(Hsub, fast_csr_matrix))
    Hsub = G - H
    assert_(not isinstance(Hsub, fast_csr_matrix))
    Hmult = H*G
    assert_(not isinstance(Hmult, fast_csr_matrix))
    Hmult = G*H
    assert_(not isinstance(Hmult, fast_csr_matrix))

def test_sp_inf_norm():
    "Sparse: inf-norm"
    for kk in range(10):
        H = rand_herm(100,0.1).data
        nrm = sp_inf_norm(H)
        ans = max(abs(H).sum(axis=1).flat)
        assert_almost_equal(nrm,ans)

def test_fast_sparse_adjoint():
    "fastsparse: adjoint operations"
    H = rand_herm(5).data
    assert_(isinstance(H, fast_csr_matrix))
    assert_(isinstance(H.H, fast_csr_matrix))
    assert_(isinstance(H.getH(), fast_csr_matrix))
    assert_(isinstance(H.adjoint(), fast_csr_matrix))

def test_fast_sparse_trans():
    "fastsparse: transpose operations"
    H = rand_herm(5).data
    assert_(isinstance(H, fast_csr_matrix))
    assert_(isinstance(H.T, fast_csr_matrix))
    assert_(isinstance(H.trans(), fast_csr_matrix))
    assert_(isinstance(H.transpose(), fast_csr_matrix))

def test_isherm_skew():
    """
    mul and tensor of skew-Hermitian operators report ``isherm = True``.
    """
    iH = 1j * rand_herm(5)

    assert_(not iH.isherm)
    assert_((iH * iH).isherm)
    assert_(tensor(iH, iH).isherm)

 def test_SuperChoiSuper(self):
     """
     Superoperator: Converting superoperator to Choi matrix and back.
     """
     h_5 = rand_herm(5)
     superoperator = propagator(h_5, scipy.rand(),
                                [create(5), destroy(5), jmat(2, 'z')])
     choi_matrix = super_to_choi(superoperator)
     test_supe = choi_to_super(choi_matrix)
     assert_((test_supe - superoperator).norm() < 1e-12)

def test_QobjNorm():
    "Qobj norm"
    # vector L2-norm test
    N = 20
    x = np.random.random(N) + 1j * np.random.random(N)
    A = Qobj(x)
    assert_equal(np.abs(A.norm() - la.norm(A.data.data, 2)) < 1e-12, True)
    # vector max (inf) norm test
    assert_equal(
        np.abs(A.norm('max') - la.norm(A.data.data, np.inf)) < 1e-12, True)
    # operator frobius norm
    x = np.random.random((N, N)) + 1j * np.random.random((N, N))
    A = Qobj(x)
    assert_equal(
        np.abs(A.norm('fro') - la.norm(A.full(), 'fro')) < 1e-12, True)
    # operator trace norm
    a = rand_herm(10,0.25)
    assert_almost_equal(a.norm(), (a*a.dag()).sqrtm().tr().real)
    b = rand_herm(10,0.25) - 1j*rand_herm(10,0.25)
    assert_almost_equal(b.norm(), (b*b.dag()).sqrtm().tr().real)

def test_cosm():
    """
    Test Qobj: cosm
    """
    A = rand_herm(5)

    B = A.cosm().full()

    C = la.cosm(A.full())

    assert_(np.all((B-C)< 1e-14))

def test_sinm():
    """
    Test Qobj: sinm
    """
    A = rand_herm(5)

    B = A.sinm().full()

    C = la.sinm(A.full())

    assert_(np.all((B-C)< 1e-14))

 def test_ChoiKrausChoi(self):
     """
     Superoperator: Converting superoperator to Choi matrix and back.
     """
     h_5 = rand_herm(5)
     superoperator = propagator(h_5, scipy.rand(),
                                [create(5), destroy(5), jmat(2, 'z')])
     choi_matrix = super_to_choi(superoperator)
     kraus_ops = choi_to_kraus(choi_matrix)
     test_choi = kraus_to_choi(kraus_ops)
     assert_((test_choi - choi_matrix).norm() < 1e-12)