Implements map and ref for both static & dynamic mode
See merge request oss/rotgen!12
This commit is contained in:
Joel Falcou
parent
aacae1cbb1
commit
6c2b260229
58 changed files with 4121 additions and 1205 deletions
280
include/rotgen/dynamic/map.hpp
Normal file
280
include/rotgen/dynamic/map.hpp
Normal file
|
|
@ -0,0 +1,280 @@
|
|||
//==================================================================================================
|
||||
/*
|
||||
ROTGEN - Runtime Overlay for Eigen
|
||||
Copyright : CODE RECKONS
|
||||
SPDX-License-Identifier: BSL-1.0
|
||||
*/
|
||||
//==================================================================================================
|
||||
#pragma once
|
||||
|
||||
#include <rotgen/concepts.hpp>
|
||||
#include <rotgen/impl/map.hpp>
|
||||
#include <cassert>
|
||||
|
||||
namespace rotgen
|
||||
{
|
||||
template<typename Ref, int Options = ColMajor, typename = void>
|
||||
class map : public find_map<Ref>
|
||||
{
|
||||
public:
|
||||
|
||||
static_assert ( concepts::entity<Ref>
|
||||
, "[ROTGEN][CRITICAL] - Map of non-rotgen type instanciated"
|
||||
);
|
||||
|
||||
using parent = find_map<Ref>;
|
||||
using rotgen_tag = void;
|
||||
using value_type = typename std::remove_const_t<Ref>::value_type;
|
||||
using concrete_type = typename std::remove_const_t<Ref>::concrete_type;
|
||||
static constexpr int storage_order = Ref::storage_order;
|
||||
static constexpr bool has_static_storage = false;
|
||||
|
||||
static constexpr bool is_immutable = std::is_const_v<Ref>;
|
||||
static constexpr bool is_defined_static = false;
|
||||
|
||||
using ptr_type = std::conditional_t<is_immutable, value_type const*, value_type*>;
|
||||
using stride_type = stride;
|
||||
|
||||
static constexpr Index RowsAtCompileTime = Ref::RowsAtCompileTime;
|
||||
static constexpr Index ColsAtCompileTime = Ref::ColsAtCompileTime;
|
||||
|
||||
map(ptr_type ptr, Index r, Index c, stride_type s) : parent(ptr, r, c,s) {}
|
||||
map(ptr_type ptr, Index r, Index c) : map(ptr, r, c, strides<storage_order>(r,c)) {}
|
||||
|
||||
map(ptr_type ptr, stride_type s) requires(RowsAtCompileTime!=-1 && ColsAtCompileTime!=-1)
|
||||
: parent(ptr,RowsAtCompileTime,ColsAtCompileTime, s)
|
||||
{}
|
||||
|
||||
map(ptr_type ptr, Index size) requires(RowsAtCompileTime==1 || ColsAtCompileTime==1)
|
||||
: map( ptr, RowsAtCompileTime==1?1:size, ColsAtCompileTime==1?1:size)
|
||||
{}
|
||||
|
||||
map(ptr_type ptr) requires(RowsAtCompileTime!=-1 && ColsAtCompileTime!=-1)
|
||||
: map( ptr, RowsAtCompileTime, ColsAtCompileTime )
|
||||
{}
|
||||
|
||||
template<typename R2, int O2, typename S2>
|
||||
map(map<R2,O2,S2> const& other) : map ( other.data(), other.rows(), other.cols()
|
||||
, stride{other.outerStride(),other.innerStride()}
|
||||
)
|
||||
{}
|
||||
|
||||
map(parent const& base) : parent(base) {}
|
||||
|
||||
map(map const& other) : parent(other)
|
||||
{}
|
||||
|
||||
map& operator=(map const& other) requires(!is_immutable)
|
||||
{
|
||||
base() = static_cast<parent const &>(*other);
|
||||
return *this;
|
||||
}
|
||||
|
||||
value_type& operator()(Index i, Index j) requires(!is_immutable) { return parent::operator()(i,j); }
|
||||
value_type& operator()(Index i) requires(!is_immutable)
|
||||
{
|
||||
assert( parent::innerStride() == 1
|
||||
&& parent::outerStride() ==(storage_order == RowMajor ? parent::cols() : parent::rows())
|
||||
);
|
||||
return parent::operator()(i);
|
||||
}
|
||||
|
||||
value_type operator()(Index i, Index j) const { return parent::operator()(i,j); }
|
||||
value_type operator()(Index i) const
|
||||
{
|
||||
assert( parent::innerStride() == 1
|
||||
&& parent::outerStride() ==(storage_order == RowMajor ? parent::cols() : parent::rows())
|
||||
);
|
||||
return parent::operator()(i);
|
||||
}
|
||||
|
||||
concrete_type transpose() const
|
||||
{
|
||||
return concrete_type(static_cast<parent const &>(*this).transpose());
|
||||
}
|
||||
|
||||
concrete_type conjugate() const
|
||||
{
|
||||
return concrete_type(static_cast<parent const &>(*this).conjugate());
|
||||
}
|
||||
|
||||
concrete_type adjoint() const
|
||||
{
|
||||
return concrete_type(static_cast<parent const &>(*this).adjoint());
|
||||
}
|
||||
|
||||
void transposeInPlace() requires(!is_immutable) { parent::transposeInPlace(); }
|
||||
void adjointInPlace() requires(!is_immutable) { parent::adjointInPlace(); }
|
||||
|
||||
map& operator+=(map const& rhs) requires(!is_immutable)
|
||||
{
|
||||
base() += static_cast<parent const&>(rhs);
|
||||
return *this;
|
||||
}
|
||||
|
||||
map& operator-=(map const& rhs) requires(!is_immutable)
|
||||
{
|
||||
base() -= static_cast<parent const&>(rhs);
|
||||
return *this;
|
||||
}
|
||||
|
||||
concrete_type operator-() const
|
||||
{
|
||||
return concrete_type(base().operator-());
|
||||
}
|
||||
|
||||
map& operator*=(map const& rhs) requires(!is_immutable)
|
||||
{
|
||||
base() *= static_cast<parent const&>(rhs);
|
||||
return *this;
|
||||
}
|
||||
|
||||
map& operator*=(value_type rhs) requires(!is_immutable)
|
||||
{
|
||||
base() *= rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
map& operator/=(value_type rhs) requires(!is_immutable)
|
||||
{
|
||||
base() /= rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
static auto Zero() requires( requires {Ref::Zero();} )
|
||||
{
|
||||
return Ref::Zero();
|
||||
}
|
||||
|
||||
static auto Zero(int rows, int cols)
|
||||
{
|
||||
return Ref::Zero(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& setZero() requires(!is_immutable)
|
||||
{
|
||||
parent::setZero();
|
||||
return *this;
|
||||
}
|
||||
|
||||
map& setOnes() requires(!is_immutable)
|
||||
{
|
||||
parent::setOnes();
|
||||
return *this;
|
||||
}
|
||||
|
||||
map& setIdentity() requires(!is_immutable)
|
||||
{
|
||||
parent::setIdentity();
|
||||
return *this;
|
||||
}
|
||||
|
||||
map& setRandom() requires(!is_immutable)
|
||||
{
|
||||
parent::setRandom();
|
||||
return *this;
|
||||
}
|
||||
|
||||
map& setConstant(value_type s) requires(!is_immutable)
|
||||
{
|
||||
parent::setConstant(s);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<int P>
|
||||
double lpNorm() const
|
||||
{
|
||||
assert(P == 1 || P == 2 || P == Infinity);
|
||||
return parent::lpNorm(P);
|
||||
}
|
||||
|
||||
parent& base() { return static_cast<parent&>(*this); }
|
||||
parent const& base() const { return static_cast<parent const&>(*this); }
|
||||
};
|
||||
|
||||
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().add(map<R1,O1,S1>(rhs)));
|
||||
}
|
||||
|
||||
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().sub(map<R1,O1,S1>(rhs)));
|
||||
}
|
||||
|
||||
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().mul(map<R1,O1,S1>(rhs)));
|
||||
}
|
||||
|
||||
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().mul(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().mul(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().div(s));
|
||||
}
|
||||
|
||||
template<typename R1, int O1, typename S1, typename R2, 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, int O1, typename S1, typename R2, int O2, typename S2>
|
||||
bool operator!=(map<R1,O1,S1> const& lhs, map<R2,O2,S2> const& rhs)
|
||||
{
|
||||
return lhs.base() != rhs.base();
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue