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

trajectree/quimb/tests/test_linalg/test_base_linalg.py

@@ -0,0 +1,351 @@
+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

@@ -0,0 +1,127 @@
+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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,134 @@
+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