codereckons/rotgen
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Adapt generator static functions as free functions.

Browse source
This commit is contained in:
Joel Falcou 2025-09-20 16:44:45 +02:00
parent fe68663ab9
commit 62802273e4
3 changed files with 223 additions and 87 deletions
Download patch file Download diff file Expand all files Collapse all files

10
include/rotgen/dynamic/matrix.hpp
View file

@ -282,7 +282,7 @@ namespace rotgen
matrix& setOnes()
{
*this = parent::Ones(Rows, Cols);
*this = parent::Ones(parent::rows(), parent::cols());
return *this;
}
@ -294,7 +294,7 @@ namespace rotgen
matrix& setZero()
{
*this = parent::Zero(Rows, Cols);
*this = parent::Zero(parent::rows(), parent::cols());
return *this;
}
@ -306,7 +306,7 @@ namespace rotgen
matrix& setConstant(Scalar value)
{
*this = parent::Constant(Rows, Cols, static_cast<Scalar>(value));
*this = parent::Constant(parent::rows(), parent::cols(), static_cast<Scalar>(value));
return *this;
}
@ -318,7 +318,7 @@ namespace rotgen
matrix& setRandom()
{
*this = parent::Random(Rows, Cols);
*this = parent::Random(parent::rows(), parent::cols());
return *this;
}
@ -330,7 +330,7 @@ namespace rotgen
matrix& setIdentity()
{
*this = parent::Identity(Rows, Cols);
*this = parent::Identity(parent::rows(), parent::cols());
return *this;
}

155
include/rotgen/functions.hpp
View file

@ -9,6 +9,9 @@
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(); }
@ -39,6 +42,9 @@ namespace rotgen
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(); }
@ -48,18 +54,17 @@ namespace rotgen
void transposeInPlace(concepts::entity auto& arg) { arg.transposeInPlace(); }
void adjointInPlace(concepts::entity auto& arg) { arg.adjointInPlace(); }
auto abs(concepts::entity auto const& arg) { return arg.cwiseAbs(); }
auto abs2(concepts::entity auto const& arg) { return arg.cwiseAbs2(); }
auto rec(concepts::entity auto const& arg) { return arg.cwiseInverse(); }
auto sqrt(concepts::entity auto const& arg) { return arg.cwiseSqrt(); }
#if defined(ROTGEN_ENABLE_EXPRESSION_TEMPLATES)
decltype(auto) abs(concepts::eigen_compatible auto const& arg) { return arg.cwiseAbs(); }
decltype(auto) abs2(concepts::eigen_compatible auto const& arg) { return arg.cwiseAbs2(); }
decltype(auto) rec(concepts::eigen_compatible auto const& arg) { return arg.cwiseInverse(); }
decltype(auto) sqrt(concepts::eigen_compatible auto const& arg) { return arg.cwiseSqrt(); }
#endif
//-----------------------------------------------------------------------------------------------
// 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(); }
@ -94,6 +99,9 @@ namespace rotgen
return arg.template lpNorm<P>();
}
//-----------------------------------------------------------------------------------------------
// Expression handling
//-----------------------------------------------------------------------------------------------
template<typename T>
decltype(auto) noalias(T&& t) requires( requires{std::forward<T>(t).noalias();} )
{
@ -111,4 +119,127 @@ namespace rotgen
{
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);
}
}