t3toolbox.backend.tucker_tensor_train.dense_t3svd.ttsvd_dense
=============================================================

.. py:function:: t3toolbox.backend.tucker_tensor_train.dense_t3svd.ttsvd_dense(T: t3toolbox.backend.common.NDArray, min_ranks: t3toolbox.backend.common.typ.Sequence[int] = None, max_ranks: t3toolbox.backend.common.typ.Sequence[int] = None, rtol: float = None, atol: float = None, use_jax: bool = False) -> t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.NDArray, Ellipsis], t3toolbox.backend.common.typ.Tuple[t3toolbox.backend.common.NDArray, Ellipsis]]

   Compute tensor train (TT) decomposition and unfolding singular values for dense tensor.

   :param T: The dense tensor. shape=(N1, ..., Nd)
   :type T: NDArray
   :param min_ranks: Minimum TT-ranks for truncation. len=d+1. e.g., (1,3,3,3,1)
   :type min_ranks: typ.Sequence[int]
   :param max_ranks: Maximum TT-ranks for truncation. len=d+1. e.g., (1,5,5,5,1)
   :type max_ranks: typ.Sequence[int]
   :param rtol: Relative tolerance for truncation.
   :type rtol: float
   :param atol: Absolute tolerance for truncation.
   :type atol: float
   :param xnp: Linear algebra backend. Default: np (numpy)

   :returns: * *typ.Tuple[NDArray,...]* -- TT cores. len=d. elm_shape=(ri, ni, r(i+1))
             * *typ.Tuple[NDArray,...]* -- Singular values of unfoldings. len=d+1. elm_shape=(ri,)

   .. seealso:: :py:obj:`truncated_svd`, :py:obj:`tucker_svd_dense`, :py:obj:`t3_svd_dense`, :py:obj:`t3_svd`

   .. rubric:: Examples

   >>> import numpy as np
   >>> import t3toolbox.t3svd as t3svd
   >>> T0 = np.random.randn(40, 50, 60)
   >>> c0 = 1.0 / np.arange(1, 41)**2
   >>> c1 = 1.0 / np.arange(1, 51)**2
   >>> c2 = 1.0 / np.arange(1, 61)**2
   >>> T = np.einsum('ijk,i,j,k->ijk', T0, c0, c1, c2) # Preconditioned random tensor
   >>> cores, ss = t3svd.tt_svd_dense(T, rtol=1e-3) # Truncate TT-SVD to reduce rank
   >>> print([G.shape for G in cores])
   [(1, 40, 13), (13, 50, 13), (13, 60, 1)]
   >>> T2 = np.einsum('aib,bjc,ckd->ijk', cores[0], cores[1], cores[2])
   >>> print(np.linalg.norm(T - T2) / np.linalg.norm(T)) # should be slightly more than rtol=1e-3
   0.0023999063535883633