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
202
test/unit/map/operators.cpp
Normal file
202
test/unit/map/operators.cpp
Normal file
|
|
@ -0,0 +1,202 @@
|
|||
//==================================================================================================
|
||||
/*
|
||||
ROTGEN - Runtime Overlay for Eigen
|
||||
Copyright : CODE RECKONS
|
||||
SPDX-License-Identifier: BSL-1.0
|
||||
*/
|
||||
//==================================================================================================
|
||||
#include "unit/tests.hpp"
|
||||
#include <rotgen/rotgen.hpp>
|
||||
#include <vector>
|
||||
|
||||
template <typename MatrixType>
|
||||
void test_map_operations(rotgen::Index rows, rotgen::Index cols, auto a_init_fn, auto b_init_fn, auto ops, auto self_ops)
|
||||
{
|
||||
MatrixType a_data(rows, cols);
|
||||
MatrixType b_data(rows, cols);
|
||||
MatrixType ref_data;
|
||||
|
||||
for (rotgen::Index r = 0; r < rows; ++r)
|
||||
for (rotgen::Index c = 0; c < cols; ++c)
|
||||
{
|
||||
a_data(r,c) = a_init_fn(r, c);
|
||||
b_data(r,c) = b_init_fn(r, c);
|
||||
}
|
||||
|
||||
ref_data = ops(a_data, b_data);
|
||||
rotgen::map<MatrixType> a_map(a_data.data(), rows, cols);
|
||||
rotgen::map<MatrixType> b_map(b_data.data(), rows, cols);
|
||||
|
||||
TTS_EQUAL(ops(a_map, b_map), ref_data);
|
||||
self_ops(a_map, b_map);
|
||||
TTS_EQUAL(a_map, ref_data);
|
||||
|
||||
TTS_EXPECT(verify_rotgen_reentrance(ops(a_map, b_map)));
|
||||
TTS_EXPECT(verify_rotgen_reentrance(self_ops(a_map, b_map)));
|
||||
}
|
||||
|
||||
template <typename MatrixType>
|
||||
void test_map_scalar_operations(rotgen::Index rows, rotgen::Index cols, auto fn, auto s, auto ops, auto self_ops)
|
||||
{
|
||||
MatrixType a_data(rows, cols);
|
||||
MatrixType ref_data;
|
||||
|
||||
for (rotgen::Index r = 0; r < rows; ++r)
|
||||
for (rotgen::Index c = 0; c < cols; ++c)
|
||||
a_data(r,c) = fn(r, c);
|
||||
|
||||
ref_data = ops(a_data, s);
|
||||
rotgen::map<MatrixType> a_map(a_data.data(), rows, cols);
|
||||
|
||||
TTS_EQUAL(ops(a_map, s), ref_data);
|
||||
self_ops(a_map, s);
|
||||
TTS_EQUAL(a_map, ref_data);
|
||||
|
||||
TTS_EXPECT(verify_rotgen_reentrance(ops(a_map, s)));
|
||||
TTS_EXPECT(verify_rotgen_reentrance(self_ops(a_map, s)));
|
||||
}
|
||||
|
||||
template <typename MatrixType>
|
||||
void test_map_scalar_multiplications(rotgen::Index rows, rotgen::Index cols, auto fn, auto s)
|
||||
{
|
||||
MatrixType a_data(rows, cols);
|
||||
MatrixType ref_data;
|
||||
|
||||
for (rotgen::Index r = 0; r < rows; ++r)
|
||||
for (rotgen::Index c = 0; c < cols; ++c)
|
||||
a_data(r,c) = fn(r, c);
|
||||
|
||||
ref_data = a_data * s;
|
||||
rotgen::map<MatrixType> a_map(a_data.data(), rows, cols);
|
||||
|
||||
TTS_EQUAL(a_map * s, ref_data);
|
||||
TTS_EQUAL(s * a_map, ref_data);
|
||||
a_map *= s;
|
||||
TTS_EQUAL(a_map, ref_data);
|
||||
|
||||
TTS_EXPECT(verify_rotgen_reentrance(a_map * s));
|
||||
TTS_EXPECT(verify_rotgen_reentrance(s * a_map));
|
||||
TTS_EXPECT(verify_rotgen_reentrance(a_map *= s));
|
||||
}
|
||||
|
||||
template <typename MatrixType>
|
||||
void test_map_multiplication(rotgen::Index rows, rotgen::Index cols, auto a_init_fn, auto b_init_fn)
|
||||
{
|
||||
MatrixType a_data(rows, cols);
|
||||
MatrixType b_data(cols, rows);
|
||||
MatrixType ref_data;
|
||||
|
||||
for (rotgen::Index r = 0; r < rows; ++r)
|
||||
for (rotgen::Index c = 0; c < cols; ++c)
|
||||
{
|
||||
a_data(r,c) = a_init_fn(r,c);
|
||||
b_data(c,r) = b_init_fn(c,r);
|
||||
}
|
||||
|
||||
ref_data = a_data * b_data;
|
||||
rotgen::map<MatrixType> a_map(a_data.data(), rows, cols);
|
||||
rotgen::map<MatrixType> b_map(b_data.data(), cols, rows);
|
||||
|
||||
TTS_EQUAL(a_map * b_map, ref_data);
|
||||
TTS_EXPECT(verify_rotgen_reentrance(a_map * b_map));
|
||||
|
||||
if(rows == cols)
|
||||
{
|
||||
a_map *= b_map;
|
||||
TTS_EQUAL(a_map, ref_data);
|
||||
TTS_EXPECT(verify_rotgen_reentrance(a_map *= b_map));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
inline constexpr auto init_a = [](auto r, auto c) { return 9.9*r*r*r - 6*c - 12; };
|
||||
inline constexpr auto init_b = [](auto r, auto c) { return 3.1*r + 4.2*c - 12.3; };
|
||||
inline constexpr auto init_0 = [](auto , auto ) { return 0; };
|
||||
|
||||
TTS_CASE_TPL("Check map addition", rotgen::tests::types)
|
||||
<typename T, typename O>( tts::type< tts::types<T,O>> )
|
||||
{
|
||||
using mat_t = rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value>;
|
||||
auto op = [](auto a, auto b) { return a + b; };
|
||||
auto s_op = [](auto& a, auto b) { return a += b; };
|
||||
|
||||
test_map_operations<mat_t>(1 , 1, init_a, init_b, op, s_op);
|
||||
test_map_operations<mat_t>(3 , 5, init_a, init_b, op, s_op);
|
||||
test_map_operations<mat_t>(5 , 3, init_a, init_b, op, s_op);
|
||||
test_map_operations<mat_t>(5 , 5, init_a, init_b, op, s_op);
|
||||
test_map_operations<mat_t>(5 , 5, init_b, init_a, op, s_op);
|
||||
test_map_operations<mat_t>(10, 1, init_a, init_b, op, s_op);
|
||||
test_map_operations<mat_t>(1 ,10, init_a, init_b, op, s_op);
|
||||
test_map_operations<mat_t>(5 , 5, init_0, init_b, op, s_op);
|
||||
test_map_operations<mat_t>(5 , 5, init_a, init_0, op, s_op);
|
||||
};
|
||||
|
||||
TTS_CASE_TPL("Check map subtraction", rotgen::tests::types)
|
||||
<typename T, typename O>( tts::type< tts::types<T,O>> )
|
||||
{
|
||||
using mat_t = rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value>;
|
||||
auto op = [](auto a, auto b) { return a - b; };
|
||||
auto s_op = [](auto& a, auto b) { return a -= b; };
|
||||
|
||||
test_map_operations<mat_t>(1 , 1, init_a, init_b, op, s_op);
|
||||
test_map_operations<mat_t>(3 , 5, init_a, init_b, op, s_op);
|
||||
test_map_operations<mat_t>(5 , 3, init_a, init_b, op, s_op);
|
||||
test_map_operations<mat_t>(5 , 5, init_a, init_b, op, s_op);
|
||||
test_map_operations<mat_t>(5 , 5, init_b, init_a, op, s_op);
|
||||
test_map_operations<mat_t>(10, 1, init_a, init_b, op, s_op);
|
||||
test_map_operations<mat_t>(1 ,10, init_a, init_b, op, s_op);
|
||||
test_map_operations<mat_t>(5 , 5, init_0, init_b, op, s_op);
|
||||
test_map_operations<mat_t>(5 , 5, init_a, init_0, op, s_op);
|
||||
};
|
||||
|
||||
TTS_CASE_TPL("Check map multiplications", rotgen::tests::types)
|
||||
<typename T, typename O>( tts::type< tts::types<T,O>> )
|
||||
{
|
||||
using mat_t = rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value>;
|
||||
auto init_id = [](auto r, auto c) { return r == c ? 1 : 0; };
|
||||
|
||||
test_map_multiplication<mat_t>(1 , 1, init_a , init_b );
|
||||
test_map_multiplication<mat_t>(3 , 5, init_a , init_b );
|
||||
test_map_multiplication<mat_t>(5 , 3, init_a , init_b );
|
||||
test_map_multiplication<mat_t>(5 , 5, init_a , init_b );
|
||||
test_map_multiplication<mat_t>(5 , 5, init_b , init_a );
|
||||
test_map_multiplication<mat_t>(5 , 5, init_a , init_a );
|
||||
test_map_multiplication<mat_t>(5 , 5, init_a , init_id);
|
||||
test_map_multiplication<mat_t>(5 , 5, init_id, init_a );
|
||||
test_map_multiplication<mat_t>(10, 1, init_a , init_b );
|
||||
test_map_multiplication<mat_t>(1 ,10, init_a , init_b );
|
||||
test_map_multiplication<mat_t>(5 , 5, init_0 , init_b );
|
||||
test_map_multiplication<mat_t>(5 , 5, init_a , init_0 );
|
||||
};
|
||||
|
||||
TTS_CASE_TPL("Check map multiplication with scalar", rotgen::tests::types)
|
||||
<typename T, typename O>( tts::type< tts::types<T,O>> )
|
||||
{
|
||||
using mat_t = rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value>;
|
||||
|
||||
test_map_scalar_multiplications<mat_t>(1 , 1, init_a, T{ 3.5});
|
||||
test_map_scalar_multiplications<mat_t>(3 , 5, init_a, T{-2.5});
|
||||
test_map_scalar_multiplications<mat_t>(5 , 3, init_a, T{ 4. });
|
||||
test_map_scalar_multiplications<mat_t>(5 , 5, init_a, T{-5. });
|
||||
test_map_scalar_multiplications<mat_t>(5 , 5, init_a, T{ 1. });
|
||||
test_map_scalar_multiplications<mat_t>(5 , 5, init_a, T{ 6. });
|
||||
test_map_scalar_multiplications<mat_t>(10, 1, init_a, T{ 10.});
|
||||
test_map_scalar_multiplications<mat_t>(1 ,10, init_a, T{-0.5});
|
||||
};
|
||||
|
||||
TTS_CASE_TPL("Check map division with scalar", rotgen::tests::types)
|
||||
<typename T, typename O>( tts::type< tts::types<T,O>> )
|
||||
{
|
||||
using mat_t = rotgen::matrix<T,rotgen::Dynamic,rotgen::Dynamic,O::value>;
|
||||
auto op = [](auto a, auto b) { return a / b; };
|
||||
auto s_op = [](auto& a, auto b) { return a /= b; };
|
||||
|
||||
test_map_scalar_operations<mat_t>(1 , 1, init_a, T{ 3.5}, op, s_op);
|
||||
test_map_scalar_operations<mat_t>(3 , 5, init_a, T{-2.5}, op, s_op);
|
||||
test_map_scalar_operations<mat_t>(5 , 3, init_a, T{ 4. }, op, s_op);
|
||||
test_map_scalar_operations<mat_t>(5 , 5, init_a, T{-5. }, op, s_op);
|
||||
test_map_scalar_operations<mat_t>(5 , 5, init_a, T{ 1. }, op, s_op);
|
||||
test_map_scalar_operations<mat_t>(5 , 5, init_a, T{ 6. }, op, s_op);
|
||||
test_map_scalar_operations<mat_t>(10, 1, init_a, T{ 10.}, op, s_op);
|
||||
test_map_scalar_operations<mat_t>(1 ,10, init_a, T{-0.5}, op, s_op);
|
||||
};
|
||||
Loading…
Add table
Add a link
Reference in a new issue