Trajectree 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

trajectree/quimb/tests/test_linalg/test_base_linalg.py

@@ -1,351 +0,0 @@
-import pytest
-import numpy as np
-import scipy.sparse as sp
-from numpy.testing import assert_allclose
-
-import quimb as qu
-from quimb.linalg import SLEPC4PY_FOUND
-from quimb.linalg.base_linalg import _rel_window_to_abs_window
-
-eigs_backends = ["auto", "numpy", "scipy"]
-svds_backends = ["numpy", "scipy"]
-
-if SLEPC4PY_FOUND:
-    eigs_backends += ["slepc-nompi", "slepc"]
-    svds_backends += ["slepc-nompi", "slepc"]
-
-
-# --------------------------------------------------------------------------- #
-#                              Fixtures                                       #
-# --------------------------------------------------------------------------- #
-
-
-@pytest.fixture
-def mat_herm_dense():
-    np.random.seed(1)
-    u = qu.rand_uni(4)
-    a = u @ qu.ldmul(np.array([-1, 2, 4, -3]), u.H)
-    #  |--|--|--|--|--|--|--|
-    # -3    -1        2     4
-    return u, a
-
-
-@pytest.fixture
-def mat_herm_sparse():
-    np.random.seed(1)
-    u = qu.rand_uni(4)
-    a = u @ qu.ldmul(np.array([-1, 2, 4, -3]), u.H)
-    a = qu.sparse(a)
-    return u, a
-
-
-@pytest.fixture
-def mat_nherm_dense():
-    np.random.seed(1)
-    u, v = qu.rand_uni(5), qu.rand_uni(5)
-    a = u @ qu.ldmul(np.array([1, 2, 4, 3, 0.1]), v.H)
-    return u, v, a
-
-
-@pytest.fixture
-def mat_nherm_sparse():
-    np.random.seed(1)
-    u, v = qu.rand_uni(5), qu.rand_uni(5)
-    a = u @ qu.ldmul(np.array([1, 2, 4, 3, 0.1]), v.H)
-    a = qu.sparse(a)
-    return u, v, a
-
-
-@pytest.fixture
-def ham1():
-    u = qu.rand_uni(7)
-    el = np.array([-3, 0, 1, 2, 3, 4, 7])
-    return u @ qu.ldmul(el, u.H)
-
-
-@pytest.fixture
-def ham2():
-    u = qu.rand_uni(7)
-    el = np.array([-3.72, 0, 1, 1.1, 2.1, 2.2, 6.28])
-    return u @ qu.ldmul(el, u.H)
-
-
-# --------------------------------------------------------------------------- #
-#                              Tests                                          #
-# --------------------------------------------------------------------------- #
-
-
-class TestEigh:
-    def test_eigsys(self, mat_herm_dense):
-        u, a = mat_herm_dense
-        evals, v = qu.eigh(a)
-        assert set(np.rint(evals)) == set((-1, 2, 4, -3))
-        assert_allclose(evals, [-3, -1, 2, 4])
-        for i, j in zip([3, 0, 1, 2], range(4)):
-            o = u[:, [i]].H @ v[:, [j]]
-            assert_allclose(abs(o), 1.0)
-
-    def test_eigvals(self, mat_herm_dense):
-        _, a = mat_herm_dense
-        evals = qu.eigvalsh(a)
-        assert_allclose(evals, [-3, -1, 2, 4])
-
-    def test_eigvecs(self, mat_herm_dense):
-        u, a = mat_herm_dense
-        v = qu.eigvecsh(a)
-        for i, j in zip([3, 0, 1, 2], range(4)):
-            o = u[:, [i]].H @ v[:, [j]]
-            assert_allclose(abs(o), 1.0)
-
-
-class TestSeigs:
-    @pytest.mark.parametrize("backend", eigs_backends)
-    def test_eigs_small_dense_wvecs(self, mat_herm_dense, backend):
-        u, a = mat_herm_dense
-        assert not qu.issparse(a)
-        lk, vk = qu.eigh(a, k=2, backend=backend)
-        assert_allclose(lk, (-3, -1))
-        for i, j in zip([3, 0], [0, 1]):
-            o = u[:, [i]].H @ vk[:, [j]]
-            assert_allclose(abs(o), 1.0)
-        vk = qu.eigvecsh(a, k=2, backend=backend)
-        for i, j in zip([3, 0], [0, 1]):
-            o = u[:, [i]].H @ vk[:, [j]]
-            assert_allclose(abs(o), 1.0)
-
-    @pytest.mark.parametrize("backend", eigs_backends)
-    def test_eigs_small_dense_novecs(self, mat_herm_dense, backend):
-        _, a = mat_herm_dense
-        assert not qu.issparse(a)
-        lk = qu.eigvalsh(a, k=2, backend=backend)
-        assert_allclose(lk, (-3, -1))
-
-    @pytest.mark.parametrize("backend", eigs_backends)
-    def test_eigs_sparse_wvecs(self, mat_herm_sparse, backend):
-        u, a = mat_herm_sparse
-        assert qu.issparse(a)
-        lk, vk = qu.eigh(a, k=2, backend=backend)
-        assert_allclose(lk, (-3, -1))
-        for i, j in zip([3, 0], [0, 1]):
-            o = u[:, [i]].H @ vk[:, [j]]
-            assert_allclose(abs(o), 1.0)
-        vk = qu.eigvecsh(a, k=2, backend=backend)
-        for i, j in zip([3, 0], [0, 1]):
-            o = u[:, [i]].H @ vk[:, [j]]
-            assert_allclose(abs(o), 1.0)
-
-    @pytest.mark.parametrize("backend", eigs_backends)
-    def test_eigs_small_sparse_novecs(self, mat_herm_sparse, backend):
-        _, a = mat_herm_sparse
-        assert qu.issparse(a)
-        lk = qu.eigvalsh(a, k=2, backend=backend)
-        assert_allclose(lk, (-3, -1))
-
-    @pytest.mark.parametrize("backend", eigs_backends)
-    def test_groundstate(self, mat_herm_dense, backend):
-        u, a = mat_herm_dense
-        gs = qu.groundstate(a, backend=backend)
-        assert_allclose(abs(u[:, [3]].H @ gs), 1.0)
-
-    @pytest.mark.parametrize("backend", eigs_backends)
-    def test_groundenergy(self, mat_herm_dense, backend):
-        _, a = mat_herm_dense
-        ge = qu.groundenergy(a, backend=backend)
-        assert_allclose(ge, -3)
-
-    @pytest.mark.parametrize("which", [None, "SA", "LA", "LM", "SM", "TR"])
-    @pytest.mark.parametrize("k", [1, 2])
-    def test_cross_equality(self, mat_herm_sparse, k, which):
-        _, a = mat_herm_sparse
-        sigma = 1 if which in {None, "TR"} else None
-        lks, vks = zip(
-            *(
-                qu.eigh(a, k=k, which=which, sigma=sigma, backend=b)
-                for b in eigs_backends
-            )
-        )
-        lks, vks = tuple(lks), tuple(vks)
-        for i in range(len(lks) - 1):
-            assert_allclose(lks[i], lks[i + 1])
-            assert_allclose(abs(vks[i].H @ vks[i + 1]), qu.eye(k), atol=1e-14)
-
-
-class TestLOBPCG:
-    def test_against_arpack(self):
-        A = qu.rand_herm(32, dtype=float)
-        lk, vk = qu.eigh(A, k=6, backend="lobpcg")
-        slk, svk = qu.eigh(A, k=6, backend="scipy")
-        assert_allclose(lk, slk)
-        assert_allclose(np.eye(6), abs(vk.H @ svk), atol=1e-9, rtol=1e-9)
-
-
-class TestEvalsWindowed:
-    @pytest.mark.parametrize("backend", eigs_backends)
-    def test_bound_spectrum(self, ham1, backend):
-        h = ham1
-        lmin, lmax = qu.bound_spectrum(h, backend=backend)
-        assert_allclose((lmin, lmax), (-3, 7), atol=1e-13)
-
-    def test_rel_window_to_abs_window(self):
-        el0 = _rel_window_to_abs_window(5, 10, 0.5)
-        assert_allclose(el0, 7.5)
-        el0, eli, elf = _rel_window_to_abs_window(-20, -10, 0.5, 0.2)
-        assert_allclose([el0, eli, elf], [-15, -16, -14])
-
-    def test_dense(self, ham2):
-        h = ham2
-        el = qu.eigvalsh_window(h, 0.5, 2, w_sz=0.1)
-        assert_allclose(el, [1, 1.1])
-
-    def test_dense_cut(self, ham1):
-        h = ham1
-        el = qu.eigvalsh_window(h, 0.5, 5, w_sz=0.3)
-        assert_allclose(el, [1, 2, 3])
-
-    @pytest.mark.parametrize("backend", eigs_backends)
-    def test_sparse(self, ham2, backend):
-        h = qu.sparse(ham2)
-        el = qu.eigvalsh_window(h, 0.5, 2, w_sz=0.1, backend=backend)
-        assert_allclose(el, [1, 1.1])
-
-    def test_sparse_cut(self, ham1):
-        h = qu.sparse(ham1)
-        el = qu.eigvalsh_window(h, 0.5, 5, w_sz=0.3)
-        assert_allclose(el, [1, 2, 3])
-
-    def test_dense_return_vecs(self, mat_herm_dense):
-        u, a = mat_herm_dense
-        ev = qu.eigvecsh_window(a, w_0=0.5, k=2, w_sz=0.8)
-        assert ev.shape == (4, 2)
-        assert_allclose(abs(u[:, :2].H @ ev[:,]), [[1, 0], [0, 1]], atol=1e-14)
-
-    def test_sparse_return_vecs(self, mat_herm_sparse):
-        u, a = mat_herm_sparse
-        ev = qu.eigvecsh_window(a, w_0=0.5, k=2, w_sz=0.8)
-        assert ev.shape == (4, 2)
-        assert_allclose(abs(u[:, :2].H @ ev[:,]), [[1, 0], [0, 1]], atol=1e-14)
-
-
-class TestSVD:
-    def test_svd_full(self, mat_nherm_dense):
-        u, v, a = mat_nherm_dense
-        un, sn, vn = qu.svd(a)
-        assert_allclose(sn, [4, 3, 2, 1, 0.1], atol=1e-14)
-        for (
-            i,
-            j,
-        ) in zip((0, 1, 2, 3, 4), (2, 3, 1, 0, 4)):
-            o = abs(un[:, [i]].H @ u[:, [j]])
-            assert_allclose(o, 1.0)
-            o = abs(vn[[i], :] @ v[:, [j]])
-            assert_allclose(o, 1.0)
-
-
-class TestSVDS:
-    @pytest.mark.parametrize("backend", svds_backends)
-    def test_svds_smalldense_wvecs(self, mat_nherm_dense, backend):
-        u, v, a = mat_nherm_dense
-        uk, sk, vk = qu.svds(a, k=3, return_vecs=True, backend=backend)
-        assert_allclose(sk, [4, 3, 2])
-        for i, j in zip((0, 1, 2), (2, 3, 1)):
-            o = abs(uk[:, [i]].H @ u[:, [j]])
-            assert_allclose(o, 1.0)
-            o = abs(vk[[i], :] @ v[:, [j]])
-            assert_allclose(o, 1.0)
-
-    @pytest.mark.parametrize("backend", svds_backends)
-    def test_svds_smalldense_nvecs(self, mat_nherm_dense, backend):
-        _, _, a = mat_nherm_dense
-        sk = qu.svds(a, k=3, return_vecs=False, backend=backend)
-        assert_allclose(sk, [4, 3, 2])
-
-    @pytest.mark.parametrize("backend", svds_backends)
-    def test_svds_sparse_wvecs(self, mat_nherm_sparse, backend):
-        u, v, a = mat_nherm_sparse
-        uk, sk, vk = qu.svds(a, k=3, return_vecs=True, backend=backend)
-        assert_allclose(sk, [4, 3, 2])
-        for i, j in zip((0, 1, 2), (2, 3, 1)):
-            o = abs(uk[:, [i]].H @ u[:, [j]])
-            assert_allclose(o, 1.0)
-            o = abs(vk[[i], :] @ v[:, [j]])
-            assert_allclose(o, 1.0)
-
-    @pytest.mark.parametrize("backend", svds_backends)
-    def test_svds_sparse_nvecs(self, mat_nherm_sparse, backend):
-        _, _, a = mat_nherm_sparse
-        sk = qu.svds(a, k=3, return_vecs=False, backend=backend)
-        assert_allclose(sk, [4, 3, 2])
-
-
-class TestNorms:
-    def test_norm_fro_dense(self):
-        a = qu.quimbify([[1, 2], [3j, 4j]])
-        assert qu.norm(a, "fro") == (1 + 4 + 9 + 16) ** 0.5
-
-    def test_norm_fro_sparse(self):
-        a = qu.sparse([[3, 0], [4j, 0]])
-        assert qu.norm(a, "fro") == (9 + 16) ** 0.5
-
-    @pytest.mark.parametrize("backend", svds_backends)
-    def test_norm_spectral_dense(self, mat_nherm_dense, backend):
-        _, _, a = mat_nherm_dense
-        assert_allclose(qu.norm(a, "spectral", backend=backend), 4.0)
-
-    @pytest.mark.parametrize("backend", svds_backends)
-    def test_norm_spectral_sparse(self, mat_nherm_sparse, backend):
-        _, _, a = mat_nherm_sparse
-        assert_allclose(qu.norm(a, "spectral", backend=backend), 4.0)
-
-    def test_norm_trace_dense(self):
-        a = qu.qarray(np.diag([-3, 1, 7]))
-        assert qu.norm(a, "trace") == 11
-        a = qu.rand_product_state(1, qtype="dop")
-        assert_allclose(qu.norm(a, "nuc"), 1)
-
-
-class TestExpm:
-    @pytest.mark.parametrize("herm", [True, False])
-    def test_zeros_dense(self, herm):
-        p = qu.expm(np.zeros((2, 2), dtype=complex), herm=herm)
-        assert_allclose(p, qu.eye(2))
-
-    @pytest.mark.parametrize("sparse", [True, False])
-    @pytest.mark.parametrize("herm", [True, False])
-    def test_eye(self, sparse, herm):
-        p = qu.expm(qu.eye(2, sparse=sparse), herm=herm)
-        assert_allclose((p.toarray() if sparse else p) / np.e, qu.eye(2))
-        if sparse:
-            assert isinstance(p, sp.csr_matrix)
-
-
-class TestSqrtm:
-    @pytest.mark.parametrize("sparse", [True, False])
-    @pytest.mark.parametrize("herm", [True, False])
-    def test_eye(self, herm, sparse):
-        if sparse:
-            with pytest.raises(NotImplementedError):
-                p = qu.sqrtm(qu.eye(2, sparse=sparse), herm=herm)
-        else:
-            p = qu.sqrtm(qu.eye(2), herm=herm)
-            assert_allclose(p, qu.eye(2))
-
-
-class TestLazy:
-    @pytest.mark.parametrize("sparse", [False, True])
-    def test_basic(self, sparse):
-        ownership = (0, 7)
-        hl = qu.Lazy(qu.ham_heis, n=4, sparse=sparse, shape=(16, 16))
-        print(hl)
-        h = 1 * hl(ownership=ownership)
-        h_ex = qu.ham_heis(n=4, sparse=sparse)[slice(*ownership), :]
-        assert_allclose(h.toarray(), h_ex.toarray())
-
-    @pytest.mark.parametrize("backend", ["scipy", "lobpcg"])
-    def test_project_eig(self, backend):
-        Hl = qu.Lazy(qu.ham_heis, 4, sparse=True, shape=(16, 16), cyclic=True)
-        Pl = qu.Lazy(qu.zspin_projector, 4, shape=(16, 6))
-
-        ge, gs = qu.eigh(Hl, P=Pl, k=1, backend=backend)
-
-        assert ge == pytest.approx(-2)
-        assert qu.expec(gs, gs) == pytest.approx(1.0)

trajectree/quimb/tests/test_linalg/test_mpi_linalg.py

@@ -1,127 +0,0 @@
-import pytest
-import numpy as np
-from numpy.testing import assert_allclose
-
-from quimb import (
-    rand_herm,
-    rand_ket,
-    eigh,
-    can_use_mpi_pool,
-)
-
-from quimb.linalg import SLEPC4PY_FOUND
-from quimb.linalg.scipy_linalg import eigs_scipy
-
-if SLEPC4PY_FOUND:
-    from quimb.linalg.mpi_launcher import (
-        eigs_slepc_spawn,
-        svds_slepc_spawn,
-        mfn_multiply_slepc_spawn,
-        ALREADY_RUNNING_AS_MPI,
-        NUM_MPI_WORKERS,
-    )
-
-slepc4py_test = pytest.mark.skipif(
-    not SLEPC4PY_FOUND, reason="No SLEPc4py installation"
-)
-
-mpipooltest = pytest.mark.skipif(
-    not can_use_mpi_pool(), reason="Not allowed to use MPI pool."
-)
-
-num_workers_to_try = [None, 1, 2, 3]
-
-
-@pytest.fixture
-def bigsparsemat():
-    import numpy as np
-
-    np.random.seed(42)
-    return rand_herm(100, sparse=True, density=0.1)
-
-
-@pytest.fixture
-def big_vec():
-    import numpy as np
-
-    np.random.seed(2442)
-    return rand_ket(100)
-
-
-@slepc4py_test
-class TestSLEPcMPI:
-    @pytest.mark.parametrize("num_workers", num_workers_to_try)
-    def test_eigs(self, num_workers, bigsparsemat):
-        if (
-            (num_workers is not None)
-            and ALREADY_RUNNING_AS_MPI
-            and num_workers > 1
-            and num_workers != NUM_MPI_WORKERS
-        ):
-            with pytest.raises(ValueError):
-                eigs_slepc_spawn(bigsparsemat, k=6, num_workers=num_workers)
-
-        else:
-            el, ev = eigs_slepc_spawn(
-                bigsparsemat, k=6, num_workers=num_workers
-            )
-            elex, evex = eigs_scipy(bigsparsemat, k=6)
-            assert_allclose(el, elex)
-            assert_allclose(np.abs(ev.H @ evex), np.eye(6), atol=1e-7)
-
-    @pytest.mark.parametrize("num_workers", num_workers_to_try)
-    def test_expm_multiply(self, num_workers, bigsparsemat, big_vec):
-        a = bigsparsemat
-        k = big_vec
-
-        if (
-            (num_workers is not None)
-            and ALREADY_RUNNING_AS_MPI
-            and num_workers > 1
-            and num_workers != NUM_MPI_WORKERS
-        ):
-            with pytest.raises(ValueError):
-                mfn_multiply_slepc_spawn(a, k, num_workers=num_workers)
-
-        else:
-            out = mfn_multiply_slepc_spawn(a, k, num_workers=num_workers)
-            al, av = eigh(a.toarray())
-            expected = av @ np.diag(np.exp(al)) @ av.conj().T @ k
-            assert_allclose(out, expected)
-
-    @pytest.mark.parametrize("num_workers", num_workers_to_try)
-    def test_svds(self, num_workers):
-        a = np.random.randn(13, 7) + 1.0j * np.random.randn(13, 7)
-
-        if (
-            (num_workers is not None)
-            and ALREADY_RUNNING_AS_MPI
-            and num_workers > 1
-            and num_workers != NUM_MPI_WORKERS
-        ):
-            with pytest.raises(ValueError):
-                svds_slepc_spawn(a, return_vecs=True, num_workers=num_workers)
-
-        else:
-            u, s, v = svds_slepc_spawn(
-                a, return_vecs=True, num_workers=num_workers
-            )
-
-
-@slepc4py_test
-@mpipooltest
-class TestMPIPool:
-    def test_spawning_pool_in_pool(self, bigsparsemat):
-        from quimb.linalg.mpi_launcher import get_mpi_pool
-
-        l1 = eigs_slepc_spawn(bigsparsemat, k=6, return_vecs=False)
-        pool = get_mpi_pool()
-        f = pool.submit(
-            eigs_slepc_spawn,
-            bigsparsemat,
-            k=6,
-            return_vecs=False,
-            num_workers=1,
-        )
-        l2 = f.result()
-        assert_allclose(l1, l2)

trajectree/quimb/tests/test_linalg/test_numpy_linalg.py

@@ -1,84 +0,0 @@
-from pytest import fixture, mark
-import numpy as np
-from numpy.testing import assert_equal, assert_allclose
-
-import quimb as qu
-from quimb.linalg.numpy_linalg import (
-    sort_inds,
-    eigs_numpy,
-)
-
-
-@fixture
-def xs():
-    return np.array([-2.4 - 1j, -1 + 2.2j, 1 - 2.1j, 2.3 + 1j])
-
-
-@fixture
-def ham1():
-    evecs = qu.rand_uni(5)
-    evals = np.array([-5, -3, 0.1, 2, 4])
-    return qu.dot(evecs, qu.ldmul(evals, evecs.H))
-
-
-class TestSortInds:
-    @mark.parametrize(
-        "method, inds, sigma",
-        [
-            ("LM", [0, 3, 1, 2], None),
-            ("SM", [2, 1, 3, 0], None),
-            ("SA", [0, 1, 2, 3], None),
-            ("SR", [0, 1, 2, 3], None),
-            ("SI", [2, 0, 3, 1], None),
-            ("LA", [3, 2, 1, 0], None),
-            ("LR", [3, 2, 1, 0], None),
-            ("LI", [1, 3, 0, 2], None),
-            ("TM", [1, 2, 3, 0], 2.41),
-            ("tm", [1, 2, 3, 0], 2.41),
-            ("TR", [2, 3, 1, 0], 1.01),
-            ("TI", [3, 1, 0, 2], 1.01),
-        ],
-    )
-    def test_simple(self, xs, method, inds, sigma):
-        assert_equal(sort_inds(xs, method, sigma), inds)
-
-
-class TestNumpyEigk:
-    @mark.parametrize(
-        "which, k, ls, sigma",
-        [
-            ("lm", 3, [-5, 4, -3], None),
-            ("sm", 3, [0.1, 2, -3], None),
-            ("tm", 3, [-3, 2, 4], 2.9),
-        ],
-    )
-    def test_evals(self, ham1, which, k, ls, sigma):
-        lk = eigs_numpy(
-            ham1, k=k, which=which, return_vecs=False, sigma=sigma, sort=False
-        )
-        assert_allclose(lk, ls)
-
-    @mark.parametrize("which, k, sigma", [("sa", 5, None)])
-    def test_evecs(self, ham1, which, k, sigma):
-        lk, vk = eigs_numpy(
-            ham1, k=k, which=which, return_vecs=True, sigma=sigma, sort=False
-        )
-        assert isinstance(vk, qu.qarray)
-        assert_allclose(qu.dot(vk, qu.ldmul(lk, vk.H)), ham1)
-
-
-class TestAutoBlock:
-    def test_eigh(self):
-        H = qu.ham_mbl(6, dh=2.5)
-        a_el, a_ev = qu.eigh(H, autoblock=False)
-        el, ev = qu.eigh(H, autoblock=True)
-
-        assert qu.norm(ev @ qu.ldmul(el, ev.H) - H, "fro") < 1e-12
-        assert_allclose(a_el, el)
-        assert_allclose(ev.H @ ev, np.eye(H.shape[0]), atol=1e-12)
-
-    def test_eigvals(self):
-        H = qu.ham_hubbard_hardcore(4)
-        a_el = qu.eigvalsh(H, autoblock=False)
-        el = qu.eigvalsh(H, autoblock=True)
-        assert_allclose(a_el, el, atol=1e-12)

trajectree/quimb/tests/test_linalg/test_rand_linalg.py

@@ -1,134 +0,0 @@
-import pytest
-import numpy as np
-from numpy.testing import assert_allclose
-
-import quimb as qu
-import quimb.tensor as qtn
-
-
-def rand_rect(m, n, sparse=False, dtype=complex):
-    X = qu.rand_matrix(max(m, n), dtype=dtype, sparse=sparse)
-    return X[:m, :n]
-
-
-def usv2dense(U, s, VH):
-    return U @ np.diag(s) @ VH
-
-
-def rand_rank(m, n, k, dtype=complex):
-    s = np.sort(qu.randn(k) ** 2)[::-1]
-
-    U = qu.gen.rand.rand_iso(m, k, dtype=dtype)
-    VH = qu.gen.rand.rand_iso(n, k, dtype=dtype).conj().T
-
-    if U.dtype in ("float32", "complex64"):
-        s = s.astype("float32")
-
-    return usv2dense(U, s, VH)
-
-
-def rand_tn1d_sect(n, bd, dtype=complex):
-    mps = qtn.MPS_rand_state(n + 2, bd, dtype=dtype)
-    mpo = qtn.MPO_rand_herm(n + 2, 5, dtype=dtype)
-
-    norm = qtn.TensorNetwork(qtn.tensor_network_align(mps.H, mpo, mps))
-    norm.view_as_(qtn.TensorNetwork1D, like=mps)
-
-    lix = qtn.bonds(norm[0], norm[1])
-    rix = qtn.bonds(norm[n], norm[n + 1])
-
-    to = norm[1 : n + 1]
-
-    return qtn.TNLinearOperator1D(to, lix, rix, 1, n + 1)
-
-
-dtypes = ["float32", "float64", "complex64", "complex128"]
-
-
-class TestRSVD:
-    @pytest.mark.parametrize("dtype", dtypes)
-    @pytest.mark.parametrize("shape", [(41, 31), (31, 41)])
-    @pytest.mark.parametrize("sparse", [False, True])
-    @pytest.mark.parametrize("q", [2, 3])
-    @pytest.mark.parametrize("p", [0, 5])
-    def test_rsvd(self, dtype, shape, sparse, q, p):
-        X = rand_rect(*shape, dtype=dtype, sparse=sparse)
-
-        k = 15
-        U, s, V = qu.rsvd(X, k, q=q, p=p)
-
-        assert U.shape == (shape[0], k)
-        assert s.shape == (k,)
-        assert V.shape == (k, shape[1])
-
-        assert U.dtype == dtype
-        assert V.dtype == dtype
-
-        assert_allclose(U.conj().T @ U, np.eye(k), rtol=1e-5, atol=1e-5)
-        assert_allclose(V @ V.conj().T, np.eye(k), rtol=1e-5, atol=1e-5)
-
-        Ue, se, Ve = qu.svds(X, k)
-        opt_err = qu.norm(X.toarray() - usv2dense(Ue, se, Ve), "fro")
-        act_err = qu.norm(X.toarray() - usv2dense(U, s, V), "fro")
-
-        assert act_err < 1.2 * opt_err
-
-        assert_allclose(s[: k // 2], se[: k // 2], rtol=0.05)
-
-    @pytest.mark.parametrize("dtype", dtypes)
-    @pytest.mark.parametrize("shape", [(41, 31), (31, 41)])
-    @pytest.mark.parametrize("q", [2, 3])
-    @pytest.mark.parametrize("p", [0, 5])
-    def test_rsvd_adaptive(self, dtype, shape, q, p):
-        X = rand_rank(*shape, 10, dtype=dtype)
-        U, s, V = qu.rsvd(X, 1e-6, q=q, p=p, k_start=10)
-
-        k = s.size
-        assert 10 <= k <= 20
-
-        assert U.dtype == dtype
-        assert V.dtype == dtype
-
-        assert_allclose(U.conj().T @ U, np.eye(k), rtol=1e-6, atol=1e-6)
-        assert_allclose(V @ V.conj().T, np.eye(k), rtol=1e-6, atol=1e-6)
-
-        Ue, se, Ve = qu.svds(X, k)
-        act_err = qu.norm(X - usv2dense(U, s, V), "fro")
-
-        assert act_err < 1e-4
-
-        assert_allclose(s[: k // 2], se[: k // 2], rtol=0.1)
-
-    @pytest.mark.parametrize("dtype", dtypes)
-    @pytest.mark.parametrize("shape", [(410, 310), (310, 410)])
-    @pytest.mark.parametrize("k_start", [4, 10, 16])
-    @pytest.mark.parametrize("use_qb", [False, 10, True])
-    def test_estimate_rank(self, dtype, shape, k_start, use_qb):
-        rnk = 100
-        X = rand_rank(*shape, rnk, dtype=dtype)
-
-        Ue, se, VHe = qu.svd(X)
-        assert_allclose(se[rnk:], 0.0, atol=1e-5)
-
-        k = qu.estimate_rank(
-            X, 1e-3, k_start=k_start, use_qb=use_qb, use_sli=False
-        )
-        assert_allclose(k, 100, rtol=0.3)
-
-        assert qu.estimate_rank(X, 1e-3, k_start=k_start, k_max=50) == 50
-
-    @pytest.mark.parametrize("dtype", dtypes)
-    @pytest.mark.parametrize("k_start", [2, 4, 8])
-    @pytest.mark.parametrize("use_qb", [False, 10, True])
-    def test_estimate_rank_lo(self, dtype, k_start, use_qb):
-        X = rand_tn1d_sect(30, 10, dtype=dtype)
-
-        Ue, se, VHe = qu.svd(X.toarray())
-        actual_rank = sum(se > se[0] * 1e-3)
-
-        k = qu.estimate_rank(
-            X, 1e-3, k_start=k_start, use_qb=use_qb, use_sli=False
-        )
-        assert_allclose(k, actual_rank, rtol=0.3 if use_qb else 0.5)
-
-        assert qu.estimate_rank(X, 1e-3, k_start=k_start, k_max=8) == 8