Implements block typs and related functions - First part
Co-authored-by: Karen <kkaspar@codereckons.com> Co-authored-by: Joel FALCOU <jfalcou@codereckons.com> See merge request oss/rotgen!9
This commit is contained in:
Karen Kaspar
Joel Falcou
parent
09be3b4b15
commit
c6b864f247
28 changed files with 1814 additions and 114 deletions
|
|
@ -12,127 +12,114 @@
|
|||
*/
|
||||
//==================================================================================================
|
||||
|
||||
//==================================================================================================
|
||||
// Internal payload
|
||||
//==================================================================================================
|
||||
struct MATRIX::payload
|
||||
{
|
||||
using data_type = Eigen::Matrix<TYPE,Eigen::Dynamic,Eigen::Dynamic,STORAGE_ORDER>;
|
||||
|
||||
data_type data;
|
||||
payload(std::size_t r=0, std::size_t c=0) : data(r, c) {}
|
||||
payload(std::initializer_list<std::initializer_list<TYPE>> init) : data(init) {}
|
||||
payload(data_type&& matrix) : data(std::move(matrix)) {}
|
||||
};
|
||||
|
||||
//==================================================================================================
|
||||
// Constructors & Special Members
|
||||
//==================================================================================================
|
||||
MATRIX::MATRIX(std::size_t r, std::size_t c) : storage_(std::make_unique<payload>(r,c)) {}
|
||||
CLASSNAME::CLASSNAME(std::size_t r, std::size_t c) : storage_(std::make_unique<payload>(r,c)) {}
|
||||
|
||||
MATRIX::MATRIX(std::initializer_list<std::initializer_list<TYPE>> init)
|
||||
CLASSNAME::CLASSNAME(std::initializer_list<std::initializer_list<TYPE>> init)
|
||||
: storage_(std::make_unique<payload>(init))
|
||||
{}
|
||||
|
||||
MATRIX::MATRIX(std::size_t r, std::size_t c,std::initializer_list<TYPE> init)
|
||||
: MATRIX(r,c)
|
||||
CLASSNAME::CLASSNAME(std::size_t r, std::size_t c,std::initializer_list<TYPE> init)
|
||||
: CLASSNAME(r,c)
|
||||
{
|
||||
auto first = init.begin();
|
||||
for(std::size_t i=0; i < init.size(); i++)
|
||||
(*this)(i) = first[i];
|
||||
}
|
||||
|
||||
MATRIX::MATRIX(MATRIX const& o)
|
||||
: MATRIX(o.rows(),o.cols())
|
||||
CLASSNAME::CLASSNAME(CLASSNAME const& o)
|
||||
: CLASSNAME(o.rows(),o.cols())
|
||||
{
|
||||
storage_->data = o.storage_->data;
|
||||
}
|
||||
|
||||
MATRIX::MATRIX(MATRIX&&) noexcept = default;
|
||||
CLASSNAME::CLASSNAME(CLASSNAME&&) noexcept = default;
|
||||
|
||||
|
||||
MATRIX& MATRIX::operator=(MATRIX const& o)
|
||||
CLASSNAME& CLASSNAME::operator=(CLASSNAME const& o)
|
||||
{
|
||||
if (this != &o) storage_->data = o.storage_->data;
|
||||
return *this;
|
||||
}
|
||||
|
||||
MATRIX& MATRIX::operator=(MATRIX&&) noexcept = default;
|
||||
CLASSNAME& CLASSNAME::operator=(CLASSNAME&&) noexcept = default;
|
||||
|
||||
MATRIX::~MATRIX() = default;
|
||||
CLASSNAME::~CLASSNAME() = default;
|
||||
|
||||
//==================================================================================================
|
||||
// Matrix API
|
||||
//==================================================================================================
|
||||
std::size_t MATRIX::rows() const { return static_cast<std::size_t>(storage_->data.rows()); }
|
||||
std::size_t MATRIX::cols() const { return static_cast<std::size_t>(storage_->data.cols()); }
|
||||
std::size_t MATRIX::size() const { return static_cast<std::size_t>(storage_->data.size()); }
|
||||
std::size_t CLASSNAME::rows() const { return static_cast<std::size_t>(storage_->data.rows()); }
|
||||
std::size_t CLASSNAME::cols() const { return static_cast<std::size_t>(storage_->data.cols()); }
|
||||
std::size_t CLASSNAME::size() const { return static_cast<std::size_t>(storage_->data.size()); }
|
||||
|
||||
void MATRIX::resize(std::size_t new_rows, std::size_t new_cols)
|
||||
void CLASSNAME::resize(std::size_t new_rows, std::size_t new_cols)
|
||||
{
|
||||
storage_->data.resize(new_rows, new_cols);
|
||||
}
|
||||
|
||||
void MATRIX::conservativeResize(std::size_t new_rows, std::size_t new_cols)
|
||||
void CLASSNAME::conservativeResize(std::size_t new_rows, std::size_t new_cols)
|
||||
{
|
||||
storage_->data.conservativeResize(new_rows, new_cols);
|
||||
}
|
||||
|
||||
TYPE& MATRIX::operator()(std::size_t i, std::size_t j) { return storage_->data(i,j); }
|
||||
TYPE const& MATRIX::operator()(std::size_t i, std::size_t j) const { return storage_->data(i,j); }
|
||||
TYPE& CLASSNAME::operator()(std::size_t i, std::size_t j) { return storage_->data(i,j); }
|
||||
TYPE const& CLASSNAME::operator()(std::size_t i, std::size_t j) const { return storage_->data(i,j); }
|
||||
|
||||
TYPE& MATRIX::operator()(std::size_t index) { return storage_->data(index); }
|
||||
TYPE const& MATRIX::operator()(std::size_t index) const { return storage_->data(index); }
|
||||
TYPE& CLASSNAME::operator()(std::size_t index) { return storage_->data(index); }
|
||||
TYPE const& CLASSNAME::operator()(std::size_t index) const { return storage_->data(index); }
|
||||
|
||||
const TYPE* MATRIX::data() const { return storage_->data.data(); }
|
||||
const TYPE* CLASSNAME::data() const { return storage_->data.data(); }
|
||||
|
||||
MATRIX MATRIX::transpose() const
|
||||
CLASSNAME CLASSNAME::transpose() const
|
||||
{
|
||||
MATRIX result(*this);
|
||||
CLASSNAME result(*this);
|
||||
result.storage_->data.transposeInPlace();
|
||||
return result;
|
||||
|
||||
}
|
||||
|
||||
MATRIX MATRIX::conjugate() const
|
||||
CLASSNAME CLASSNAME::conjugate() const
|
||||
{
|
||||
MATRIX result(*this);
|
||||
CLASSNAME result(*this);
|
||||
result.storage_->data = storage_->data.conjugate();
|
||||
return result;
|
||||
}
|
||||
|
||||
MATRIX MATRIX::adjoint() const
|
||||
CLASSNAME CLASSNAME::adjoint() const
|
||||
{
|
||||
MATRIX result(*this);
|
||||
CLASSNAME result(*this);
|
||||
result.storage_->data.adjointInPlace();
|
||||
return result;
|
||||
}
|
||||
|
||||
void MATRIX::transposeInPlace()
|
||||
void CLASSNAME::transposeInPlace()
|
||||
{
|
||||
storage_->data.transposeInPlace();
|
||||
}
|
||||
|
||||
void MATRIX::adjointInPlace()
|
||||
void CLASSNAME::adjointInPlace()
|
||||
{
|
||||
storage_->data.adjointInPlace();
|
||||
}
|
||||
|
||||
TYPE MATRIX::sum() const { return storage_->data.sum(); }
|
||||
TYPE MATRIX::prod() const { return storage_->data.prod(); }
|
||||
TYPE MATRIX::mean() const { return storage_->data.mean(); }
|
||||
TYPE MATRIX::trace() const { return storage_->data.trace(); }
|
||||
TYPE CLASSNAME::sum() const { return storage_->data.sum(); }
|
||||
TYPE CLASSNAME::prod() const { return storage_->data.prod(); }
|
||||
TYPE CLASSNAME::mean() const { return storage_->data.mean(); }
|
||||
TYPE CLASSNAME::trace() const { return storage_->data.trace(); }
|
||||
|
||||
TYPE MATRIX::minCoeff() const { return storage_->data.minCoeff(); }
|
||||
TYPE MATRIX::maxCoeff() const { return storage_->data.maxCoeff(); }
|
||||
TYPE CLASSNAME::minCoeff() const { return storage_->data.minCoeff(); }
|
||||
TYPE CLASSNAME::maxCoeff() const { return storage_->data.maxCoeff(); }
|
||||
|
||||
TYPE MATRIX::minCoeff(std::ptrdiff_t* row, std::ptrdiff_t* col) const { return storage_->data.minCoeff(row, col); }
|
||||
TYPE MATRIX::maxCoeff(std::ptrdiff_t* row, std::ptrdiff_t* col) const { return storage_->data.maxCoeff(row, col); }
|
||||
TYPE CLASSNAME::minCoeff(std::ptrdiff_t* row, std::ptrdiff_t* col) const { return storage_->data.minCoeff(row, col); }
|
||||
TYPE CLASSNAME::maxCoeff(std::ptrdiff_t* row, std::ptrdiff_t* col) const { return storage_->data.maxCoeff(row, col); }
|
||||
|
||||
TYPE MATRIX::squaredNorm() const { return storage_->data.squaredNorm(); }
|
||||
TYPE MATRIX::norm() const { return storage_->data.norm(); }
|
||||
TYPE CLASSNAME::squaredNorm() const { return storage_->data.squaredNorm(); }
|
||||
TYPE CLASSNAME::norm() const { return storage_->data.norm(); }
|
||||
|
||||
TYPE MATRIX::lp_norm(int p) const
|
||||
TYPE CLASSNAME::lp_norm(int p) const
|
||||
{
|
||||
if (p == 1) return storage_->data.lpNorm<1>();
|
||||
else if (p == 2) return storage_->data.lpNorm<2>();
|
||||
|
|
@ -142,48 +129,48 @@ TYPE MATRIX::lp_norm(int p) const
|
|||
//==================================================================================================
|
||||
// Operators
|
||||
//==================================================================================================
|
||||
std::ostream& operator<<(std::ostream& os,MATRIX const& m)
|
||||
std::ostream& operator<<(std::ostream& os,CLASSNAME const& m)
|
||||
{
|
||||
return os << m.storage_->data;
|
||||
}
|
||||
|
||||
bool operator==(MATRIX const& lhs, MATRIX const& rhs)
|
||||
bool operator==(CLASSNAME const& lhs, CLASSNAME const& rhs)
|
||||
{
|
||||
return lhs.storage_->data == rhs.storage_->data;
|
||||
}
|
||||
|
||||
MATRIX& MATRIX::operator+=(MATRIX const& rhs)
|
||||
CLASSNAME& CLASSNAME::operator+=(CLASSNAME const& rhs)
|
||||
{
|
||||
storage_->data += rhs.storage_->data;
|
||||
return *this;
|
||||
}
|
||||
|
||||
MATRIX& MATRIX::operator-=(MATRIX const& rhs)
|
||||
CLASSNAME& CLASSNAME::operator-=(CLASSNAME const& rhs)
|
||||
{
|
||||
storage_->data -= rhs.storage_->data;
|
||||
return *this;
|
||||
}
|
||||
|
||||
MATRIX MATRIX::operator-() const
|
||||
CLASSNAME CLASSNAME::operator-() const
|
||||
{
|
||||
MATRIX result(*this);
|
||||
CLASSNAME result(*this);
|
||||
result.storage_->data = -result.storage_->data;
|
||||
return result;
|
||||
}
|
||||
|
||||
MATRIX& MATRIX::operator*=(MATRIX const& rhs)
|
||||
CLASSNAME& CLASSNAME::operator*=(CLASSNAME const& rhs)
|
||||
{
|
||||
storage_->data *= rhs.storage_->data;
|
||||
return *this;
|
||||
}
|
||||
|
||||
MATRIX& MATRIX::operator*=(TYPE s)
|
||||
CLASSNAME& CLASSNAME::operator*=(TYPE s)
|
||||
{
|
||||
storage_->data *= s;
|
||||
return *this;
|
||||
}
|
||||
|
||||
MATRIX& MATRIX::operator/=(TYPE s)
|
||||
CLASSNAME& CLASSNAME::operator/=(TYPE s)
|
||||
{
|
||||
storage_->data /= s;
|
||||
return *this;
|
||||
|
|
@ -193,30 +180,30 @@ MATRIX& MATRIX::operator/=(TYPE s)
|
|||
// Static functions
|
||||
//==================================================================================================
|
||||
|
||||
MATRIX MATRIX::Zero(std::size_t rows, std::size_t cols)
|
||||
CLASSNAME CLASSNAME::Zero(std::size_t rows, std::size_t cols)
|
||||
{
|
||||
MATRIX m;
|
||||
CLASSNAME m;
|
||||
m.storage_ = std::make_unique<payload>(payload::data_type::Zero(rows, cols));
|
||||
return m;
|
||||
}
|
||||
|
||||
MATRIX MATRIX::Constant(std::size_t rows, std::size_t cols, TYPE value)
|
||||
CLASSNAME CLASSNAME::Constant(std::size_t rows, std::size_t cols, TYPE value)
|
||||
{
|
||||
MATRIX m;
|
||||
CLASSNAME m;
|
||||
m.storage_ = std::make_unique<payload>(payload::data_type::Constant(rows, cols, value));
|
||||
return m;
|
||||
}
|
||||
|
||||
MATRIX MATRIX::Random(std::size_t rows, std::size_t cols)
|
||||
CLASSNAME CLASSNAME::Random(std::size_t rows, std::size_t cols)
|
||||
{
|
||||
MATRIX m;
|
||||
CLASSNAME m;
|
||||
m.storage_ = std::make_unique<payload>(payload::data_type::Random(rows, cols));
|
||||
return m;
|
||||
}
|
||||
|
||||
MATRIX MATRIX::Identity(std::size_t rows, std::size_t cols)
|
||||
CLASSNAME CLASSNAME::Identity(std::size_t rows, std::size_t cols)
|
||||
{
|
||||
MATRIX m;
|
||||
CLASSNAME m;
|
||||
m.storage_ = std::make_unique<payload>(payload::data_type::Identity(rows, cols));
|
||||
return m;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue