Multiply.h

Go to the documentation of this file.

#pragma once

 
#include <concepts>
 
#include <Eigen/Core>
 
namespace Emrys::internal
{

inline constexpr int largeProductSize = EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD;

[[nodiscard]] consteval bool
isLargeFixedShape(int rows, int depth, int cols)
{
    if (rows == Eigen::Dynamic || depth == Eigen::Dynamic || cols == Eigen::Dynamic)
    {
        return false;
    }
    return depth > 1 && !(rows == 1 && cols == 1)
        && (depth >= largeProductSize || (rows >= largeProductSize && cols >= largeProductSize));
}

template <typename Lhs, typename Rhs>
inline constexpr bool isLargeFixedProduct =
    isLargeFixedShape(Lhs::RowsAtCompileTime, Lhs::ColsAtCompileTime, Rhs::ColsAtCompileTime);

template <typename Lhs, typename Rhs>
[[nodiscard]] auto
multiply(Eigen::EigenBase<Lhs> const & lhs, Eigen::EigenBase<Rhs> const & rhs)
{
    if constexpr (std::derived_from<Lhs, Eigen::MatrixBase<Lhs>> && std::derived_from<Rhs, Eigen::MatrixBase<Rhs>>
                  && isLargeFixedProduct<Lhs, Rhs>)
    {
        return lhs.derived().lazyProduct(rhs.derived());
    }
    else
    {
        return lhs.derived() * rhs.derived();
    }
}

template <int Mode, typename Derived>
[[nodiscard]] auto
asTriangular(Eigen::MatrixBase<Derived> const & matrix)
{
    if constexpr (Derived::RowsAtCompileTime != Eigen::Dynamic && Derived::ColsAtCompileTime != Eigen::Dynamic)
    {
        typename Derived::PlainObject result = matrix.template triangularView<Mode>();
        return result;
    }
    else
    {
        return matrix.template triangularView<Mode>();
    }
}
 
}  // namespace Emrys::internal