320 lines
11 KiB
C++
320 lines
11 KiB
C++
//==================================================================================================
|
|
/*
|
|
ROTGEN - Runtime Overlay for Eigen
|
|
Copyright : CODE RECKONS
|
|
SPDX-License-Identifier: BSL-1.0
|
|
*/
|
|
//==================================================================================================
|
|
#pragma once
|
|
|
|
#include <rotgen/detail/static_info.hpp>
|
|
#include <Eigen/Dense>
|
|
#include <iostream>
|
|
|
|
namespace rotgen
|
|
{
|
|
namespace detail
|
|
{
|
|
template<typename Ref, int Options, bool isConst>
|
|
struct compute_map_type
|
|
{
|
|
using base = Eigen::Matrix< typename Ref::value_type
|
|
, Ref::RowsAtCompileTime, Ref::ColsAtCompileTime
|
|
, Ref::storage_order
|
|
>;
|
|
|
|
using ref_t = std::conditional_t<isConst, base const, base>;
|
|
using type = Eigen::Map<ref_t, Options, Eigen::Stride<-1,-1>>;
|
|
};
|
|
|
|
template<typename Ref, int Options, bool isConst>
|
|
using map_type = typename compute_map_type<Ref,Options,isConst>::type;
|
|
}
|
|
|
|
template<typename Ref, int Options = ColMajor, typename Stride = stride>
|
|
class map : private detail::map_type<std::remove_const_t<Ref>, Options, std::is_const_v<Ref>>
|
|
{
|
|
public:
|
|
using rotgen_tag = void;
|
|
using parent = detail::map_type<std::remove_const_t<Ref>, Options, std::is_const_v<Ref>>;
|
|
using value_type = typename std::remove_const_t<Ref>::value_type;
|
|
using concrete_type = typename std::remove_const_t<Ref>::concrete_type;
|
|
|
|
static constexpr auto Flags = Ref::Flags;
|
|
static constexpr Index RowsAtCompileTime = Ref::RowsAtCompileTime;
|
|
static constexpr Index ColsAtCompileTime = Ref::ColsAtCompileTime;
|
|
static constexpr bool has_static_storage = Ref::has_static_storage;
|
|
static constexpr int storage_order = Ref::storage_order;
|
|
static constexpr bool is_immutable = std::is_const_v<Ref>;
|
|
static constexpr bool is_defined_static = Ref::is_defined_static;
|
|
|
|
template<typename ET>
|
|
using as_concrete_type = as_concrete_t<ET, matrix>;
|
|
|
|
using ptr_type = std::conditional_t<is_immutable, value_type const*, value_type*>;
|
|
using stride_type = Stride;
|
|
|
|
map(const map&) = default;
|
|
map(map&&) = default;
|
|
map& operator=(const map&) = default;
|
|
map& operator=(map&&) = default;
|
|
|
|
map(ptr_type ptr, Index r, Index c, stride_type s) : parent(ptr, r, c, strides<storage_order>(s)) {}
|
|
map(ptr_type ptr, Index r, Index c) : parent(ptr, r, c, strides<storage_order>(r,c)) {}
|
|
|
|
map(ptr_type ptr, stride_type s) requires(RowsAtCompileTime!=-1 && ColsAtCompileTime!=-1)
|
|
: parent(ptr, strides<storage_order>(s))
|
|
{}
|
|
|
|
map(ptr_type ptr, Index sz) requires(RowsAtCompileTime==1 || ColsAtCompileTime==1)
|
|
: map(ptr, RowsAtCompileTime==1?1:sz, ColsAtCompileTime==1?1:sz)
|
|
{}
|
|
|
|
map(ptr_type ptr) requires(RowsAtCompileTime!=-1 && ColsAtCompileTime!=-1)
|
|
: map( ptr, RowsAtCompileTime, ColsAtCompileTime )
|
|
{}
|
|
|
|
parent& base() { return static_cast<parent&>(*this); }
|
|
parent const& base() const { return static_cast<const parent&>(*this); }
|
|
|
|
value_type& operator()(Index i, Index j) { return base()(i, j); }
|
|
value_type operator()(Index i, Index j) const { return base()(i, j); }
|
|
|
|
value_type& operator()(Index i) requires(!is_immutable)
|
|
{
|
|
assert(is_contiguous_linear());
|
|
return base().data()[i];
|
|
}
|
|
|
|
value_type operator()(Index i) const
|
|
{
|
|
assert(is_contiguous_linear());
|
|
return base().data()[i];
|
|
}
|
|
|
|
map& operator+=(map const& rhs)
|
|
{
|
|
base() += rhs.base();
|
|
return *this;
|
|
}
|
|
|
|
map& operator-=(map const& rhs)
|
|
{
|
|
base() -= rhs.base();
|
|
return *this;
|
|
}
|
|
|
|
map& operator*=(map const& rhs)
|
|
{
|
|
base() *= rhs;
|
|
return *this;
|
|
}
|
|
|
|
map& operator*=(value_type rhs)
|
|
{
|
|
base() *= rhs;
|
|
return *this;
|
|
}
|
|
|
|
map& operator/=(value_type rhs)
|
|
{
|
|
base() /= rhs;
|
|
return *this;
|
|
}
|
|
|
|
auto transpose() const
|
|
{
|
|
if constexpr(use_expression_templates) return base().transpose();
|
|
else return as_concrete_type<decltype(base().transpose())>(base().transpose());
|
|
}
|
|
|
|
auto adjoint() const
|
|
{
|
|
if constexpr(use_expression_templates) return base().adjoint();
|
|
else return as_concrete_type<decltype(base().adjoint())>(base().adjoint());
|
|
}
|
|
|
|
auto conjugate() const
|
|
{
|
|
if constexpr(use_expression_templates) return base().conjugate();
|
|
else return as_concrete_type<decltype(base().conjugate())>(base().conjugate());
|
|
}
|
|
|
|
void transposeInPlace() { base().transposeInPlace(); }
|
|
void adjointInPlace() { base().adjointInPlace(); }
|
|
|
|
static auto Zero() requires( requires {Ref::Zero();} ) { return Ref::Zero(); }
|
|
static auto Zero(int rows, int cols) { return Ref::Zero(rows,cols); }
|
|
|
|
static auto Ones() requires( requires {Ref::Ones();} ) { return Ref::Ones(); }
|
|
static auto Ones(int rows, int cols) { return Ref::Ones(rows,cols); }
|
|
|
|
static auto Constant(value_type value) requires( requires {Ref::Constant(value);} )
|
|
{ return Ref::Constant(value); }
|
|
|
|
static auto Constant(int rows, int cols, value_type value) { return Ref::Constant(rows, cols, value); }
|
|
|
|
static auto Random() requires( requires {Ref::Random();} ) { return Ref::Random(); }
|
|
static auto Random(int rows, int cols) { return Ref::Random(rows, cols); }
|
|
|
|
static auto Identity() requires( requires {Ref::Identity();} ) { return Ref::Identity(); }
|
|
static auto Identity(int rows, int cols) { return Ref::Identity(rows, cols); }
|
|
|
|
map& setOnes()
|
|
{
|
|
base() = parent::Ones(base().rows(), base().cols());
|
|
return *this;
|
|
}
|
|
|
|
map& setZero()
|
|
{
|
|
base() = parent::Zero(base().rows(), base().cols());
|
|
return *this;
|
|
}
|
|
|
|
map& setConstant(value_type value)
|
|
{
|
|
base() = parent::Constant(base().rows(), base().cols(), value);
|
|
return *this;
|
|
}
|
|
|
|
map& setRandom()
|
|
{
|
|
base() = parent::Random(base().rows(), base().cols());
|
|
return *this;
|
|
}
|
|
|
|
map& setIdentity()
|
|
{
|
|
base() = parent::Identity(base().rows(), base().cols());
|
|
return *this;
|
|
}
|
|
|
|
bool is_contiguous_linear() const
|
|
{
|
|
if(base().innerStride() != 1) return false;
|
|
if constexpr(storage_order == rotgen::RowMajor) return base().outerStride() == base().cols();
|
|
else return base().outerStride() == base().rows();
|
|
}
|
|
|
|
using parent::innerStride;
|
|
using parent::outerStride;
|
|
using parent::rows;
|
|
using parent::cols;
|
|
using parent::size;
|
|
using parent::data;
|
|
using parent::sum;
|
|
using parent::mean;
|
|
using parent::prod;
|
|
using parent::trace;
|
|
using parent::maxCoeff;
|
|
using parent::minCoeff;
|
|
using parent::norm;
|
|
using parent::squaredNorm;
|
|
|
|
template<int P> value_type lpNorm() const
|
|
{
|
|
static_assert(P == 1 || P == 2 || P == Infinity);
|
|
return parent::template lpNorm<P>();
|
|
}
|
|
};
|
|
|
|
template<typename R1, typename R2, int O1, typename S1, int O2, typename S2>
|
|
bool operator==(map<R1, O1, S1> const& lhs, map<R2,O2,S2> const& rhs)
|
|
{
|
|
return lhs.base() == rhs.base();
|
|
}
|
|
|
|
template<typename R1, typename R2, int O1, typename S1, int O2, typename S2>
|
|
bool operator!=(map<R1, O1, S1> const& lhs, map<R2,O2,S2> const& rhs)
|
|
{
|
|
return lhs.base() != rhs.base();
|
|
}
|
|
|
|
#if defined(ROTGEN_ENABLE_EXPRESSION_TEMPLATES)
|
|
template<typename R1, typename R2, int O1, typename S1, int O2, typename S2>
|
|
auto operator+(map<R1, O1, S1> const& lhs, map<R2,O2,S2> const& rhs)
|
|
{
|
|
return lhs.base() + rhs.base();
|
|
}
|
|
|
|
template<typename R1, typename R2, int O1, typename S1, int O2, typename S2>
|
|
auto operator-(map<R1, O1, S1> const& lhs, map<R2,O2,S2> const& rhs)
|
|
{
|
|
return lhs.base() - rhs.base();
|
|
}
|
|
|
|
template<typename R1, typename R2, int O1, typename S1, int O2, typename S2>
|
|
auto operator*(map<R1, O1, S1> const& lhs, map<R2,O2,S2> const& rhs)
|
|
{
|
|
return lhs.base() * rhs.base();
|
|
}
|
|
|
|
template<typename R, int O, typename S>
|
|
auto operator*( map<R, O, S> const& lhs, std::convertible_to<typename R::value_type> auto s)
|
|
{
|
|
return lhs.base() * s;
|
|
}
|
|
|
|
template<typename R, int O, typename S>
|
|
auto operator*(std::convertible_to<typename R::value_type> auto s, map<R, O, S> const& rhs)
|
|
{
|
|
return s * rhs.base();
|
|
}
|
|
|
|
template<typename R, int O, typename S>
|
|
auto operator/(map<R, O, S> const& lhs, std::convertible_to<typename R::value_type> auto s)
|
|
{
|
|
return lhs.base() / s;
|
|
}
|
|
#else
|
|
template<typename R1, typename R2, int O1, typename S1, int O2, typename S2>
|
|
typename map<R1,O1,S1>::concrete_type operator+(map<R1, O1, S1> const& lhs, map<R2,O2,S2> const& rhs)
|
|
{
|
|
using concrete_type = typename map<R1,O1,S1>::concrete_type;
|
|
return concrete_type(lhs.base() + rhs.base());
|
|
}
|
|
|
|
template<typename R1, typename R2, int O1, typename S1, int O2, typename S2>
|
|
typename map<R1,O1,S1>::concrete_type operator-(map<R1, O1, S1> const& lhs, map<R2,O2,S2> const& rhs)
|
|
{
|
|
using concrete_type = typename map<R1,O1,S1>::concrete_type;
|
|
return concrete_type(lhs.base() - rhs.base());
|
|
}
|
|
|
|
template<typename R1, typename R2, int O1, typename S1, int O2, typename S2>
|
|
typename map<R1,O1,S1>::concrete_type operator*(map<R1, O1, S1> const& lhs, map<R2,O2,S2> const& rhs)
|
|
{
|
|
using concrete_type = typename map<R1,O1,S1>::concrete_type;
|
|
return concrete_type(lhs.base() * rhs.base());
|
|
}
|
|
|
|
template<typename R, int O, typename S>
|
|
typename map<R,O,S>::concrete_type operator*( map<R, O, S> const& lhs
|
|
, std::convertible_to<typename R::value_type> auto s
|
|
)
|
|
{
|
|
using concrete_type = typename map<R,O,S>::concrete_type;
|
|
return concrete_type(lhs.base() * s);
|
|
}
|
|
|
|
template<typename R, int O, typename S>
|
|
typename map<R,O,S>::concrete_type operator*( std::convertible_to<typename R::value_type> auto s
|
|
, map<R, O, S> const& rhs
|
|
)
|
|
{
|
|
using concrete_type = typename map<R,O,S>::concrete_type;
|
|
return concrete_type(rhs.base() * s);
|
|
}
|
|
|
|
template<typename R, int O, typename S>
|
|
typename map<R,O,S>::concrete_type operator/( map<R, O, S> const& lhs
|
|
, std::convertible_to<typename R::value_type> auto s
|
|
)
|
|
{
|
|
using concrete_type = typename map<R,O,S>::concrete_type;
|
|
return concrete_type(lhs.base() / s);
|
|
}
|
|
#endif
|
|
|
|
}
|