rotgen/include/rotgen/functions.hpp

//==================================================================================================
/*
  ROTGEN - Runtime Overlay for Eigen
  Copyright : CODE RECKONS
  SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#pragma once

namespace rotgen
{
  //-----------------------------------------------------------------------------------------------
  // Infos & Shape
  //-----------------------------------------------------------------------------------------------
  std::size_t rows(concepts::entity auto const& arg) { return arg.rows(); }
  std::size_t cols(concepts::entity auto const& arg) { return arg.cols(); }
  std::size_t size(concepts::entity auto const& arg) { return arg.size(); }

  template<concepts::entity E>
  void resize(E& arg, int sz) requires requires{arg.resize(sz);}
  {
    arg.resize(sz);
  }

  template<concepts::entity E>
  void resize(E& arg, int new_rows, int new_cols)
  requires(E::RowsAtCompileTime == -1 && E::ColsAtCompileTime == -1)
  {
    arg.resize(new_rows, new_cols);
  }

  template<concepts::entity E>
  void conservativeResize(E& arg, int sz) requires requires{arg.conservativeResize(sz);}
  {
    arg.conservativeResize(sz);
  }

  template<concepts::entity E>
  void conservativeResize(E& arg, int new_rows, int new_cols)
  requires(E::RowsAtCompileTime == -1 && E::ColsAtCompileTime == -1)
  {
    arg.conservativeResize(new_rows, new_cols);
  }

  //-----------------------------------------------------------------------------------------------
  // Global operations
  //-----------------------------------------------------------------------------------------------
  decltype(auto) normalized(concepts::entity auto const& arg) { return arg.normalized();  }
  decltype(auto) transpose (concepts::entity auto const& arg) { return arg.transpose();   }
  decltype(auto) conjugate (concepts::entity auto const& arg) { return arg.conjugate();   }
  decltype(auto) adjoint   (concepts::entity auto const& arg) { return arg.adjoint();     }

  void normalize(concepts::entity auto& arg)        { arg.normalize();        }
  void transposeInPlace(concepts::entity auto& arg) { arg.transposeInPlace(); }
  void adjointInPlace(concepts::entity auto& arg)   { arg.adjointInPlace();   }

  //-----------------------------------------------------------------------------------------------
  // Component-wise functions
  //-----------------------------------------------------------------------------------------------
  auto abs (auto const& arg) requires(requires{arg.cwiseAbs();}    ) { return arg.cwiseAbs();     }
  auto abs2(auto const& arg) requires(requires{arg.cwiseAbs2();}   ) { return arg.cwiseAbs2();    }
  auto rec (auto const& arg) requires(requires{arg.cwiseInverse();}) { return arg.cwiseInverse(); }
  auto sqrt(auto const& arg) requires(requires{arg.cwiseSqrt();}   ) { return arg.cwiseSqrt();    }

  //-----------------------------------------------------------------------------------------------
  // Reductions
  //-----------------------------------------------------------------------------------------------
  auto trace(concepts::entity auto const& arg)        { return arg.trace(); }
  auto squaredNorm(concepts::entity auto const& arg)  { return arg.squaredNorm(); }
  auto norm(concepts::entity auto const& arg)         { return arg.norm(); }
  auto sum(concepts::entity auto const& arg)          { return arg.sum(); }
  auto prod(concepts::entity auto const& arg)         { return arg.prod(); }
  auto mean(concepts::entity auto const& arg)         { return arg.mean(); }

  auto maxCoeff(auto const& arg)
  requires( requires{ arg.maxCoeff(); } )
  {
    return arg.maxCoeff();
  }

  auto minCoeff(concepts::entity auto const& arg)     { return arg.minCoeff(); }

  template<std::integral IndexType>
  auto maxCoeff(concepts::entity auto const& arg, IndexType* row, IndexType* col)
  {
    return arg.maxCoeff(row, col);
  }

  template<std::integral IndexType>
  auto minCoeff(concepts::entity auto const& arg, IndexType* row, IndexType* col)
  {
    return arg.minCoeff(row, col);
  }

  template<int P>
  auto lpNorm(concepts::entity auto const& arg)
  {
    static_assert(P == 1 || P == 2 || P == Infinity);
    return arg.template lpNorm<P>();
  }

  //-----------------------------------------------------------------------------------------------
  // Expression handling
  //-----------------------------------------------------------------------------------------------
  template<typename T>
  decltype(auto) noalias(T&& t) requires( requires{std::forward<T>(t).noalias();} )
  {
    return std::forward<T>(t).noalias();
  }

  template<typename T>
  auto evaluate(T&& t) requires( requires{std::forward<T>(t).evaluate();} )
  {
    return std::forward<T>(t).evaluate();
  }

  template<typename T>
  auto evaluate(T&& t) requires( requires{std::forward<T>(t).eval();} )
  {
    return std::forward<T>(t).eval();
  }

  //-----------------------------------------------------------------------------------------------
  // Generators
  //-----------------------------------------------------------------------------------------------
  template<typename T>
  auto setZero(T&& t) requires( requires{std::forward<T>(t).setZero();} )
  {
    return std::forward<T>(t).setZero();
  }

  template<typename T>
  auto setZero() requires( requires{T::Zero();} )
  {
    return T::Zero();
  }

  template<typename T>
  auto setZero(std::integral auto n) requires( requires{T::Zero(n);} )
  {
     return T::Zero(n);
  }

  template<typename T>
  auto setZero(std::integral auto r,std::integral auto c) requires( requires{T::Zero(r,c);} )
  {
    return T::Zero(r,c);
  }

  template<typename T>
  auto setOnes(T&& t) requires( requires{std::forward<T>(t).setOnes();} )
  {
    return std::forward<T>(t).setOnes();
  }

  template<typename T>
  auto setOnes() requires( requires{T::Ones();} )
  {
    return T::Ones();
  }

  template<typename T>
  auto setOnes(std::integral auto n) requires( requires{T::Ones(n);} )
  {
     return T::Ones(n);
  }

  template<typename T>
  auto setOnes(std::integral auto r,std::integral auto c) requires( requires{T::Ones(r,c);} )
  {
    return T::Ones(r,c);
  }

  template<typename T>
  auto setIdentity(T&& t) requires( requires{std::forward<T>(t).setIdentity();} )
  {
    return std::forward<T>(t).setIdentity();
  }

  template<typename T>
  auto setIdentity() requires( requires{T::Identity();} )
  {
    return T::Identity();
  }

  template<typename T>
  auto setIdentity(std::integral auto n) requires( requires{T::Identity(n);} )
  {
     return T::Identity(n);
  }

  template<typename T>
  auto setIdentity(std::integral auto r,std::integral auto c) requires( requires{T::Identity(r,c);} )
  {
    return T::Identity(r,c);
  }

  template<typename T>
  auto setRandom(T&& t) requires( requires{std::forward<T>(t).setRandom();} )
  {
    return std::forward<T>(t).setRandom();
  }

  template<typename T>
  auto setRandom() requires( requires{T::Random();} )
  {
    return T::Random();
  }

  template<typename T>
  auto setRandom(std::integral auto n) requires( requires{T::Random(n);} )
  {
     return T::Random(n);
  }

  template<typename T>
  auto setRandom(std::integral auto r,std::integral auto c) requires( requires{T::Random(r,c);} )
  {
    return T::Random(r,c);
  }

  template<typename T>
  auto setConstant(T&& t, auto v) requires( requires{std::forward<T>(t).setConstant(v);} )
  {
    return std::forward<T>(t).setConstant(v);
  }

  template<typename T>
  auto setConstant(auto v) requires( requires{T::Constant(v);} )
  {
    return T::Constant(v);
  }

  template<typename T>
  auto setConstant(std::integral auto n, auto v) requires( requires{T::Constant(n,v);} )
  {
     return T::Constant(n,v);
  }

  template<typename T>
  auto setConstant(std::integral auto r,std::integral auto c, auto v) requires( requires{T::Constant(r,c,v);} )
  {
    return T::Constant(r,c,v);
  }
}