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

First batch of rotgen implementation: constructors, basic infrastructure

Browse source
This commit is contained in:
Joel Falcou 2025-05-16 16:01:17 +02:00
commit f3bbc6933f
9 changed files with 428 additions and 10 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -10,3 +10,4 @@ compile_commands.json
CTestTestfile.cmake
_deps
build/*
.idea

2
CMakeLists.txt
View file

@ -44,7 +44,7 @@ add_library(rotgen SHARED ${SOURCES})
set_target_properties(rotgen PROPERTIES VERSION ${PROJECT_VERSION})
set_target_properties(rotgen PROPERTIES SOVERSION ${PROJECT_VERSION_MAJOR})
target_compile_features(rotgen INTERFACE cxx_std_17)
target_compile_options(rotgen PUBLIC -std=c++20 -Werror -Wall -Wextra -Wshadow -Wunused-variable)
set_target_properties(rotgen PROPERTIES EXPORT_NAME rotgen)
add_library(rotgen::rotgen ALIAS rotgen)

16
include/rotgen/impl/matrix_impl64.hpp
View file

@ -9,6 +9,7 @@
#include <memory>
#include <cstddef>
#include <initializer_list>
namespace rotgen
{
@ -16,10 +17,14 @@ namespace rotgen
{
public:
matrix_impl64(std::size_t rows = 0, std::size_t cols = 0);
matrix_impl64(std::size_t rows, std::size_t cols,std::initializer_list<double> init);
matrix_impl64(std::initializer_list<std::initializer_list<double>> init);
matrix_impl64(matrix_impl64 const& other);
matrix_impl64& operator=(matrix_impl64 const& other);
matrix_impl64(matrix_impl64&&) noexcept;
matrix_impl64& operator=(matrix_impl64 const& other);
matrix_impl64& operator=(matrix_impl64&&) noexcept;
~matrix_impl64();
@ -27,9 +32,16 @@ namespace rotgen
std::size_t rows() const;
std::size_t cols() const;
std::size_t size() const;
void resize(std::size_t new_rows, std::size_t new_cols);
void conservativeResize(std::size_t new_rows, std::size_t new_cols);
double& operator()(std::size_t i, std::size_t j);
double const& operator()(std::size_t i, std::size_t j) const;
double& operator()(std::size_t index);
double const& operator()(std::size_t index) const;
matrix_impl64& operator+=(matrix_impl64 const& rhs);
matrix_impl64& operator*=(matrix_impl64 const& rhs);
matrix_impl64& operator*=(double d);
@ -37,6 +49,8 @@ namespace rotgen
friend std::ostream& operator<<(std::ostream&,matrix_impl64 const&);
friend bool operator==(matrix_impl64 const& lhs, matrix_impl64 const& rhs);
const double* data() const;
private:
struct payload;
std::unique_ptr<payload> storage_;

38
include/rotgen/matrix.hpp
View file

@ -8,6 +8,8 @@
#pragma once
#include <rotgen/impl/matrix_impl64.hpp>
#include <initializer_list>
#include <cassert>
namespace rotgen
{
@ -20,7 +22,41 @@ namespace rotgen
public:
matrix() : parent(Rows==-1?0:Rows,Cols==-1?0:Cols) {}
matrix(std::size_t r, std::size_t c) : parent(r,c) {}
matrix(int r, int c) : parent(r, c)
{
if constexpr(Rows != -1) assert(r == Rows && "Mismatched between dynamic and static row size");
if constexpr(Cols != -1) assert(c == Cols && "Mismatched between dynamic and static column size");
}
matrix(std::initializer_list<std::initializer_list<Scalar>> init) : parent(init)
{
if constexpr(Rows != -1) assert(init.size() == Rows && "Mismatched between dynamic and static row size");
if constexpr(Cols != -1)
{
std::size_t c = 0;
if(init.size()) c = init.begin()->size();
assert(c == Cols && "Mismatched between dynamic and static column size");
}
}
template<std::convertible_to<Scalar>... S>
matrix(Scalar s0,S... init)
requires((Rows == 1 && Cols == (1+sizeof...(S))) || (Cols == 1 && Rows == (1+sizeof...(S))))
: parent(Rows, Cols, {s0,static_cast<Scalar>(init)...})
{}
void resize(int new_rows, int new_cols)
requires(Rows == -1 && Cols == -1)
{
parent::resize(new_rows, new_cols);
}
void conservativeResize(int new_rows, int new_cols)
requires(Rows == -1 && Cols == -1)
{
parent::conservativeResize(new_rows, new_cols);
}
friend bool operator==(matrix const& lhs, matrix const& rhs)
{

29
src/matrix_impl64.cpp
View file

@ -17,6 +17,7 @@ namespace rotgen
{
Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic> data;
payload(std::size_t r=0, std::size_t c=0) : data(r, c) {}
payload(std::initializer_list<std::initializer_list<double>> init) : data(init) {}
};
@ -25,19 +26,34 @@ namespace rotgen
//==================================================================================================
matrix_impl64::matrix_impl64(std::size_t r, std::size_t c) : storage_(std::make_unique<payload>(r,c)) {}
matrix_impl64::matrix_impl64(std::initializer_list<std::initializer_list<double>> init)
: storage_(std::make_unique<payload>(init))
{}
matrix_impl64::matrix_impl64(std::size_t r, std::size_t c,std::initializer_list<double> init)
: matrix_impl64(r,c)
{
auto first = init.begin();
for(std::size_t i=0; i < init.size(); i++)
(*this)(i) = first[i];
}
matrix_impl64::matrix_impl64(matrix_impl64 const& o)
: matrix_impl64(o.storage_->data.rows(),o.storage_->data.cols())
: matrix_impl64(o.rows(),o.cols())
{
storage_->data = o.storage_->data;
}
matrix_impl64::matrix_impl64(matrix_impl64&&) noexcept = default;
matrix_impl64& matrix_impl64::operator=(matrix_impl64 const& o)
{
if (this != &o) storage_->data = o.storage_->data;
return *this;
}
matrix_impl64::matrix_impl64(matrix_impl64&&) noexcept = default;
matrix_impl64& matrix_impl64::operator=(matrix_impl64&&) noexcept = default;
matrix_impl64::~matrix_impl64() = default;
@ -48,9 +64,18 @@ namespace rotgen
std::size_t matrix_impl64::rows() const { return static_cast<std::size_t>(storage_->data.rows()); }
std::size_t matrix_impl64::cols() const { return static_cast<std::size_t>(storage_->data.cols()); }
std::size_t matrix_impl64::size() const { return static_cast<std::size_t>(storage_->data.size()); }
void matrix_impl64::resize(std::size_t new_rows, std::size_t new_cols) { storage_->data.resize(new_rows, new_cols); }
void matrix_impl64::conservativeResize(std::size_t new_rows, std::size_t new_cols) { storage_->data.conservativeResize(new_rows, new_cols); }
double& matrix_impl64::operator()(std::size_t i, std::size_t j) { return storage_->data(i,j); }
double const& matrix_impl64::operator()(std::size_t i, std::size_t j) const { return storage_->data(i,j); }
double& matrix_impl64::operator()(std::size_t index) { return storage_->data(index); }
double const& matrix_impl64::operator()(std::size_t index) const { return storage_->data(index); }
const double* matrix_impl64::data() const { return storage_->data.data(); }
//==================================================================================================
// Operators
//==================================================================================================

2
test/CMakeLists.txt
View file

@ -10,7 +10,7 @@ rotgen_setup_test_targets()
## Compiler options for Unit Tests
##======================================================================================================================
add_library(rotgen_test INTERFACE)
target_compile_features(rotgen_test INTERFACE cxx_std_20)
target_compile_options(rotgen_test INTERFACE -std=c++20 -Werror -Wall -Wextra -Wshadow -Wunused-variable)
target_include_directories( rotgen_test INTERFACE ${PROJECT_SOURCE_DIR}/test)
target_link_libraries(rotgen_test INTERFACE rotgen)

175
test/basic/constructors.cpp Normal file
View file

@ -0,0 +1,175 @@
//==================================================================================================
/*
ROTGEN - Runtime Overlay for Eigen
Copyright : CODE RECKONS
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#define TTS_MAIN
#include <rotgen/matrix.hpp>
#include "tts.hpp"
TTS_CASE("Default matrix dynamic constructor")
{
rotgen::matrix<double> matrix;
TTS_EQUAL(matrix.rows(), 0ULL);
TTS_EQUAL(matrix.cols(), 0ULL);
};
TTS_CASE("Default matrix static constructor")
{
rotgen::matrix<double, 4, 9> matrix;
TTS_EQUAL(matrix.rows(), 4ULL);
TTS_EQUAL(matrix.cols(), 9ULL);
};
TTS_CASE("Dynamic matrix constructor with row and columns")
{
rotgen::matrix<float> matrix(10, 5);
TTS_EQUAL(matrix.rows(), 10ULL);
TTS_EQUAL(matrix.cols(), 5ULL);
};
TTS_CASE("Static matrix constructor with row and columns")
{
rotgen::matrix<double, 6, 11> matrix(6, 11);
TTS_EQUAL(matrix.rows(), 6ULL);
TTS_EQUAL(matrix.cols(), 11ULL);
};
TTS_CASE("Copy constructor produces identical but independent matrix")
{
rotgen::matrix<double> a(3, 3);
for(std::size_t r=0;r<a.rows();r++)
for(std::size_t c=0;c<a.cols();c++)
a(r,c) = r + c;
rotgen::matrix<double> b = a;
TTS_EQUAL(b.rows(), a.rows());
TTS_EQUAL(b.cols(), a.cols());
for(std::size_t r=0;r<a.rows();r++)
for(std::size_t c=0;c<a.cols();c++)
TTS_EQUAL(b(r,c), a(r,c));
TTS_EQUAL(b(0, 0), 0.0);
TTS_EQUAL(b(1, 0), 1.0);
TTS_EQUAL(b(2, 1), 3.0);
a(0,0) = 42.0;
TTS_NOT_EQUAL(b(0,0), a(0,0));
};
TTS_CASE("Copy constructor on default matrix")
{
rotgen::matrix<double> a;
rotgen::matrix<double> b = a;
TTS_EQUAL(b.rows(), 0ULL);
TTS_EQUAL(b.cols(), 0ULL);
};
TTS_CASE("Copy constructor from const matrix")
{
const rotgen::matrix<double> a(2, 2);
auto b = a;
TTS_EQUAL(b.rows(), 2ULL);
TTS_EQUAL(b.cols(), 2ULL);
};
TTS_CASE("Copy constructor on static matrix")
{
rotgen::matrix<double, 2, 5> a;
rotgen::matrix<double, 2, 5> b = a;
TTS_EQUAL(b.rows(), 2ULL);
TTS_EQUAL(b.cols(), 5ULL);
};
/*
TTS_CASE("Copy constructor on static/dynamic matrix")
{
rotgen::matrix<double, 11, 4> a;
rotgen::matrix<double> b = a;
TTS_EQUAL(b.rows(), 11);
TTS_EQUAL(b.cols(), 4);
};
TTS_CASE("Copy constructor on dynamic/static matrix")
{
rotgen::matrix<double> a(5, 7);
rotgen::matrix<double, 5, 7> b = a;
TTS_EQUAL(b.rows(), 5);
TTS_EQUAL(b.cols(), 7);
};*/
TTS_CASE("Move constructor transfers contents")
{
rotgen::matrix<double> a(3, 3);
a(1,1) = 7;
auto ptr = a.data();
rotgen::matrix<double> b = std::move(a);
TTS_EQUAL(b(1,1), 7);
TTS_EQUAL(b.rows(), 3ULL);
TTS_EQUAL(b.cols(), 3ULL);
TTS_EXPECT(b.data() == ptr);
// TTS_EXPECT(a.data() == nullptr);
};
TTS_CASE("Move constructor from Rvalue")
{
rotgen::matrix<double> b = rotgen::matrix<double>(2, 2);
TTS_EQUAL(b.rows(), 2ULL);
TTS_EQUAL(b.cols(), 2ULL);
};
TTS_CASE("Constructor from Initializer list")
{
rotgen::matrix<double,1,1> b1 = {3.5};
TTS_EQUAL(b1.rows(), 1ULL);
TTS_EQUAL(b1.cols(), 1ULL);
TTS_EQUAL(b1(0) , 3.5);
rotgen::matrix<double,5,1> b9 = {0.01, 0.1, 1, 10, 100};
TTS_EQUAL(b9.rows(), 5ULL);
TTS_EQUAL(b9.cols(), 1ULL);
int i = 0.01;
for(std::size_t r=0;r<b9.rows();++r) {
TTS_EQUAL(b9(r,1), i);
i *= 10;
}
rotgen::matrix<double,1,3> b13 = {1.2,2.3,3.4};
TTS_EQUAL(b13.rows(), 1ULL);
TTS_EQUAL(b13.cols(), 3ULL);
TTS_EQUAL(b13(0) , 1.2);
TTS_EQUAL(b13(1) , 2.3);
TTS_EQUAL(b13(2) , 3.4);
};
TTS_CASE("Constructor from Initializer list of rows")
{
rotgen::matrix<double> b1 = {{3.5}};
TTS_EQUAL(b1.rows(), 1ULL);
TTS_EQUAL(b1.cols(), 1ULL);
TTS_EQUAL(b1(0,0) , 3.5);
rotgen::matrix<double> b23 = { {1.2,2.3,3.4}
, {10,200,3000}
};
TTS_EQUAL(b23.rows(), 2ULL);
TTS_EQUAL(b23.cols(), 3ULL);
TTS_EQUAL(b23(0,0) , 1.2);
TTS_EQUAL(b23(0,1) , 2.3);
TTS_EQUAL(b23(0,2) , 3.4);
TTS_EQUAL(b23(1,0) , 10);
TTS_EQUAL(b23(1,1) , 200);
TTS_EQUAL(b23(1,2) , 3000);
};

167
test/basic/functions.cpp Normal file
View file

@ -0,0 +1,167 @@
//==================================================================================================
/*
ROTGEN - Runtime Overlay for Eigen
Copyright : CODE RECKONS
SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#define TTS_MAIN
#include <rotgen/matrix.hpp>
#include "tts.hpp"
TTS_CASE("Function size")
{
rotgen::matrix<double> empty_matrix;
rotgen::matrix<double> matrix(3,4);
rotgen::matrix<double> row_vector(9,1);
rotgen::matrix<double> column_vector(1,5);
TTS_EQUAL(empty_matrix.size(), 0ULL);
TTS_EQUAL(matrix.size(), 12ULL);
TTS_EQUAL(row_vector.size(), 9ULL);
TTS_EQUAL(column_vector.size(), 5ULL);
};
TTS_CASE("Resizing dynamic matrix")
{
rotgen::matrix<double> a(2, 3);
for(std::size_t r=0;r<a.rows();++r)
for(std::size_t c=0;c<a.cols();++c)
a(r,c) = 42 + 2*c + r;
a.resize(3, 2);
TTS_EQUAL(a.rows(), 3ULL);
TTS_EQUAL(a.cols(), 2ULL);
for(std::size_t r=0;r<a.rows();++r)
for(std::size_t c=0;c<a.cols();++c)
TTS_GREATER(a(r,c),0);
a.resize(2,2);
TTS_EQUAL(a.rows(), 2ULL);
TTS_EQUAL(a.cols(), 2ULL);
for(std::size_t r=0;r<a.rows();++r)
for(std::size_t c=0;c<a.cols();++c)
TTS_EQUAL(a(r,c),0);
};
TTS_CASE("Resizing static matrix")
{
rotgen::matrix<double, 3, 3> a;
TTS_EXPECT_NOT_COMPILES(a, { a.resize(4, 5); });
};
TTS_CASE("Dynamix matrix conservative resizing")
{
rotgen::matrix<double> a(2, 3);
int i = 1;
for(std::size_t r=0;r<a.rows();++r)
for(std::size_t c=0;c<a.cols();++c)
a(r, c) = i++;
a.conservativeResize(2, 3);
TTS_EQUAL(a.rows(), 2ULL);
TTS_EQUAL(a.cols(), 3ULL);
i = 1;
for(std::size_t r=0;r<a.rows();++r)
for(std::size_t c=0;c<a.cols();++c)
TTS_EQUAL(a(r,c),i++);
a.conservativeResize(3, 2);
TTS_EQUAL(a.rows(), 3ULL);
TTS_EQUAL(a.cols(), 2ULL);
int expected[3][2] = { {1, 2}, {4, 5}, {0, 0} };
for(std::size_t r = 0; r < 3; ++r)
for(std::size_t c = 0; c < 2; ++c)
TTS_EQUAL(a(r, c), expected[r][c]);
a.conservativeResize(4, 4);
TTS_EQUAL(a.rows(), 4ULL);
TTS_EQUAL(a.cols(), 4ULL);
TTS_EQUAL(a(0,0), 1);
TTS_EQUAL(a(3,3), 0);
a.conservativeResize(2, 2);
TTS_EQUAL(a.rows(), 2ULL);
TTS_EQUAL(a.cols(), 2ULL);
TTS_EQUAL(a(0,0), 1);
TTS_EQUAL(a(1,1), 5);
a.conservativeResize(1, 2);
TTS_EQUAL(a.rows(), 1ULL);
TTS_EQUAL(a.cols(), 2ULL);
TTS_EQUAL(a(0,0), 1);
TTS_EQUAL(a(0,1), 2);
a.conservativeResize(0, 0);
TTS_EQUAL(a.rows(), 0ULL);
TTS_EQUAL(a.cols(), 0ULL);
a.conservativeResize(3, 3);
TTS_EQUAL(a.rows(), 3ULL);
TTS_EQUAL(a.cols(), 3ULL);
for(std::size_t r=0;r<a.rows();++r)
for(std::size_t c=0;c<a.cols();++c)
TTS_EQUAL(a(r,c),0);
};
TTS_CASE("Static matrix conservative resizing")
{
rotgen::matrix<double, 3, 3> a;
TTS_EXPECT_NOT_COMPILES(a, { a.conservativeResize(4, 5); });
};
TTS_CASE("Test coefficient accessors")
{
rotgen::matrix<double> a(3, 5);
for(std::size_t r=0;r<a.rows();++r)
for(std::size_t c=0;c<a.cols();++c)
a(r, c) = r + 2 * c + 3;
TTS_EQUAL(a(0,0), 3);
TTS_EQUAL(a(1,1), 6);
TTS_EQUAL(a(1,0), 4);
TTS_EQUAL(a(2,2), 9);
TTS_EQUAL(a(2,4), 13);
a(1, 1) = 42;
TTS_EQUAL(a(1,1), 42);
double& ref = a(2, 2);
ref = 17;
assert(a(2, 2) == 17);
};
TTS_CASE("Test one index coefficient accessors")
{
rotgen::matrix<double> a(2, 4);
int i = 1;
for(std::size_t c=0;c<a.cols();++c)
for(std::size_t r=0;r<a.rows();++r)
a(r, c) = i++;
i = 1;
for(std::size_t r=0;r<a.rows()*a.cols();++r)
TTS_EQUAL(a(r), i++);
double& ref = a(2);
ref = 999.1;
assert(a(2) == 999.1);
rotgen::matrix<double, 2, 3> b (2, 3);
i = 1;
for(std::size_t c=0;c<b.cols()*b.rows(); ++c)
a(c) = i++;
i = 1;
for(std::size_t c=0;c<b.cols();++c)
for(std::size_t r=0;r<b.rows();++r)
TTS_EQUAL(a(r, c), i++);
};

4
test/basic/operators.cpp
View file

@ -14,9 +14,9 @@ TTS_CASE("Check operator*")
rotgen::matrix<double> a(2,2);
rotgen::matrix<double> ref(2,2);
for(int r=0;r<a.rows();r++)
for(std::size_t r=0;r<a.rows();r++)
{
for(int c=0;c<a.cols();c++)
for(std::size_t c=0;c<a.cols();c++)
{
a(r,c) = (1+c) + 10*(1+r);
ref(r,c) = ((1+c) + 10*(1+r)) * 10.5;