truncate.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_TENSOR_TRAIN_ALGORITHMS_TRUNCATE_H
#define pRC_TENSOR_TRAIN_ALGORITHMS_TRUNCATE_H
 
#include <prc/core/basic/position.hpp>
#include <prc/core/functors/min.hpp>
#include <prc/core/tensor/declarations.hpp>
 
namespace pRC
{
    template<Size C, Position P, class X, IsTensorish R = RemoveReference<X>,
        IsFloat VT = Value<R>>
        requires(C < reduce<Min>(RemoveReference<decltype(folding<!P>(
                             declval<X>()))>::Sizes())) &&
        (P == Position::Right)
    static inline constexpr auto truncate(X &&a,
        VT const &tolerance = NumericLimits<VT>::epsilon())
    {
        return expand(makeSeries<Index, R::Dimension - 1>(),
            [&](auto const... seq)
            {
                auto const [u, s, v] =
                    svd<C>(folding<!P>(forward<X>(a)), tolerance);
 
                return Tuple(eval(reshape<R::size(seq)...,
                                 RemoveReference<decltype(u)>::size(1)>(u)),
                    eval(fromDiagonal(s) * adjoint(v)));
            });
    }
 
    template<Size C, Position P, class X, IsTensorish R = RemoveReference<X>,
        IsFloat VT = Value<R>>
        requires(C < reduce<Min>(RemoveReference<decltype(folding<!P>(
                             declval<X>()))>::Sizes())) &&
        (P == Position::Left)
    static inline constexpr auto truncate(X &&a,
        VT const &tolerance = NumericLimits<VT>::epsilon())
    {
        return expand(makeRange<Index, 1, R::Dimension>(),
            [&](auto const... seq)
            {
                auto const [u, s, v] =
                    svd<C>(folding<!P>(forward<X>(a)), tolerance);
 
                return Tuple(eval(u * fromDiagonal(s)),
                    eval(reshape<RemoveReference<decltype(v)>::size(1),
                        R::size(seq)...>(adjoint(v))));
            });
    }
 
    template<Size C, Position P, class X, IsTensorish R = RemoveReference<X>,
        IsFloat VT = Value<R>>
    static inline constexpr auto truncate(X &&a,
        VT const &tolerance = NumericLimits<VT>::epsilon())
    {
        return orthogonalize<!P>(forward<X>(a));
    }
}
#endif // pRC_TENSOR_TRAIN_ALGORITHMS_TRUNCATE_H