generic-library/boost
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] add v1.66.0

Browse Source
This commit is contained in:
Edouard DUPIN
2018-01-12 21:47:58 +01:00
parent 87059bb1af
commit a97e9ae7d4
49032 changed files with 7668950 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

173
libs/qvm/test/Jamfile.v2 Normal file
View File

@@ -0,0 +1,173 @@
# Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
# Distributed under the Boost Software License, Version 1.0. (See accompanying
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
import testing ;
import path ;
rule
headers-compile-test ( headers * : requirements * : target-tag ? )
{
local test-names = ;
for local header in $(headers)
{
local target = hdr$(target-tag)-$(header:D=) ;
compile header-test.cpp : $(requirements) <define>REVERGE_HEADER=\"\<boost/qvm/$(header:B).hpp\>\" <dependency>$(header) : $(target) ;
test-names += $(target) ;
}
alias hdrtest$(target-tag) : $(test-names) ;
}
headers-compile-test [ glob ../include/boost/qvm/*.hpp ]
: # requirements
: # target-tag
qvm
;
run mat_traits_array_test.cpp ;
run vec_traits_array_test.cpp ;
run quat_traits_array_test.cpp ;
run access_m_test.cpp ;
compile-fail access_m_fail1.cpp ;
compile-fail access_m_fail2.cpp ;
run access_q_test.cpp ;
compile-fail access_q_fail.cpp ;
run access_v_test.cpp ;
compile-fail access_v_fail1.cpp ;
compile-fail access_v_fail2.cpp ;
run assign_test.cpp ;
run to_string_test.cpp ;
run cmp_vv_test.cpp ;
run cross_test.cpp ;
run div_eq_vs_test.cpp ;
run div_vs_test.cpp ;
run dot_vv_test.cpp ;
run eq_vv_test.cpp ;
run mag_v_test.cpp ;
run mag_sqr_v_test.cpp ;
run minus_v_test.cpp ;
run minus_eq_vv_test.cpp ;
run minus_vv_test.cpp ;
run mul_eq_vs_test.cpp ;
run mul_vs_test.cpp ;
run mul_sv_test.cpp ;
run mul_vm_test.cpp ;
run normalize_v_test.cpp ;
run plus_eq_vv_test.cpp ;
run plus_vv_test.cpp ;
run scalar_cast_v_test.cpp ;
run vec_index_test.cpp ;
run cmp_mm_test.cpp ;
run determinant_test.cpp ;
run div_eq_ms_test.cpp ;
run div_ms_test.cpp ;
run eq_mm_test.cpp ;
run minus_m_test.cpp ;
run minus_eq_mm_test.cpp ;
run minus_mm_test.cpp ;
run mul_eq_mm_test.cpp ;
run mul_eq_ms_test.cpp ;
run mul_mm_test.cpp ;
run mul_ms_test.cpp ;
run mul_sm_test.cpp ;
run mul_mv_test.cpp ;
run inverse_m_test.cpp ;
run plus_eq_mm_test.cpp ;
run plus_mm_test.cpp ;
run scalar_cast_m_test.cpp ;
run mat_index_test.cpp ;
run cmp_qq_test.cpp ;
run conjugate_test.cpp ;
run normalize_q_test.cpp ;
run div_eq_qs_test.cpp ;
run div_qs_test.cpp ;
run dot_qq_test.cpp ;
run eq_qq_test.cpp ;
run inverse_q_test.cpp ;
run mag_q_test.cpp ;
run mag_sqr_q_test.cpp ;
run minus_q_test.cpp ;
run minus_eq_qq_test.cpp ;
run minus_qq_test.cpp ;
run mul_eq_qs_test.cpp ;
run mul_qs_test.cpp ;
run mul_qv_test.cpp ;
run mul_qq_test.cpp ;
run mul_eq_qq_test.cpp ;
run plus_eq_qq_test.cpp ;
run plus_qq_test.cpp ;
run scalar_cast_q_test.cpp ;
run slerp_test.cpp ;
run convert_to_test.cpp ;
run rot_mat_test.cpp ;
run rot_quat_test.cpp ;
run rotx_mat_test.cpp ;
run rotx_quat_test.cpp ;
run roty_mat_test.cpp ;
run roty_quat_test.cpp ;
run rotz_mat_test.cpp ;
run rotz_quat_test.cpp ;
run zero_vec_test.cpp ;
run zero_mat_test.cpp ;
run zero_quat_test.cpp ;
run identity_mat_test.cpp ;
run identity_quat_test.cpp ;
run col_test.cpp ;
run col_mat_test.cpp ;
run neg_col_test.cpp ;
run neg_row_test.cpp ;
run del_col_test.cpp ;
run del_row_test.cpp ;
run del_row_col_test.cpp ;
run swap_cols_test.cpp ;
run swap_rows_test.cpp ;
run diag_test.cpp ;
run diag_mat_test.cpp ;
run row_test.cpp ;
run row_mat_test.cpp ;
run transpose_test.cpp ;
run translation_test.cpp ;
run translation_mat_test.cpp ;
compile-fail swizzle_const_fail.cpp ;
run swizzle2_test2.cpp ;
run swizzle2_test3.cpp ;
run swizzle2_test4.cpp ;
run swizzle2_test.cpp ;
run swizzle3_test2.cpp ;
run swizzle3_test3.cpp ;
run swizzle3_test4.cpp ;
run swizzle3_test.cpp ;
run swizzle4_test2.cpp ;
run swizzle4_test3.cpp ;
run swizzle4_test4.cpp ;
run swizzle4_test.cpp ;
compile deduce_scalar_test.cpp ;
compile-fail deduce_scalar_fail1.cpp ;
compile-fail deduce_scalar_fail2.cpp ;
compile-fail deduce_scalar_fail3.cpp ;
compile deduce_matrix_test.cpp ;
compile deduce_vector_test.cpp ;
run interop_test.cpp ;
run transform_test.cpp ;
run projection_test.cpp ;
compile scalar_traits_test.cpp ;

36
libs/qvm/test/access_m_fail1.cpp Normal file
View File

@@ -0,0 +1,36 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_access.hpp>
template <int R,int C> struct my_mat { };
namespace
boost
{
namespace
qvm
{
template <int R,int C>
struct
mat_traits< my_mat<R,C> >
{
typedef int scalar_type;
static int const rows=R;
static int const cols=C;
template <int Row,int Col> static int read_element( my_mat<R,C> const & );
template <int Row,int Col> static int & write_element( my_mat<R,C> & );
};
}
}
int
main()
{
using namespace boost::qvm;
my_mat<1,1> const m=my_mat<1,1>();
A11(m);
return 1;
}

36
libs/qvm/test/access_m_fail2.cpp Normal file
View File

@@ -0,0 +1,36 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_access.hpp>
template <int R,int C> struct my_mat { };
namespace
boost
{
namespace
qvm
{
template <int R,int C>
struct
mat_traits< my_mat<R,C> >
{
typedef int scalar_type;
static int const rows=R;
static int const cols=C;
template <int Row,int Col> static int read_element( my_mat<R,C> const & );
template <int Row,int Col> static int & write_element( my_mat<R,C> & );
};
}
}
int
main()
{
using namespace boost::qvm;
my_mat<1,1> m;
A11(m);
return 1;
}

126
libs/qvm/test/access_m_test.cpp Normal file
View File

@@ -0,0 +1,126 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_access.hpp>
#include "test_qvm_matrix.hpp"
using namespace boost::qvm;
template <int R,int C>
void
check_idx( test_qvm::matrix<M1,10,10> & m, float & (*f)( test_qvm::matrix<M1,10,10> & ) )
{
BOOST_TEST((&A<R,C>(m)==&m.a[R][C]));
BOOST_TEST((&f(m)==&m.a[R][C]));
}
int
main()
{
test_qvm::matrix<M1,10,10> m;
#define CHECK_A(i,j) check_idx<i,j>(m,A##i##j);
CHECK_A(0,0);
CHECK_A(0,1);
CHECK_A(0,2);
CHECK_A(0,3);
CHECK_A(0,4);
CHECK_A(0,5);
CHECK_A(0,6);
CHECK_A(0,7);
CHECK_A(0,8);
CHECK_A(0,9);
CHECK_A(1,0);
CHECK_A(1,1);
CHECK_A(1,2);
CHECK_A(1,3);
CHECK_A(1,4);
CHECK_A(1,5);
CHECK_A(1,6);
CHECK_A(1,7);
CHECK_A(1,8);
CHECK_A(1,9);
CHECK_A(2,0);
CHECK_A(2,1);
CHECK_A(2,2);
CHECK_A(2,3);
CHECK_A(2,4);
CHECK_A(2,5);
CHECK_A(2,6);
CHECK_A(2,7);
CHECK_A(2,8);
CHECK_A(2,9);
CHECK_A(3,0);
CHECK_A(3,1);
CHECK_A(3,2);
CHECK_A(3,3);
CHECK_A(3,4);
CHECK_A(3,5);
CHECK_A(3,6);
CHECK_A(3,7);
CHECK_A(3,8);
CHECK_A(3,9);
CHECK_A(4,0);
CHECK_A(4,1);
CHECK_A(4,2);
CHECK_A(4,3);
CHECK_A(4,4);
CHECK_A(4,5);
CHECK_A(4,6);
CHECK_A(4,7);
CHECK_A(4,8);
CHECK_A(4,9);
CHECK_A(5,0);
CHECK_A(5,1);
CHECK_A(5,2);
CHECK_A(5,3);
CHECK_A(5,4);
CHECK_A(5,5);
CHECK_A(5,6);
CHECK_A(5,7);
CHECK_A(5,8);
CHECK_A(5,9);
CHECK_A(6,0);
CHECK_A(6,1);
CHECK_A(6,2);
CHECK_A(6,3);
CHECK_A(6,4);
CHECK_A(6,5);
CHECK_A(6,6);
CHECK_A(6,7);
CHECK_A(6,8);
CHECK_A(6,9);
CHECK_A(7,0);
CHECK_A(7,1);
CHECK_A(7,2);
CHECK_A(7,3);
CHECK_A(7,4);
CHECK_A(7,5);
CHECK_A(7,6);
CHECK_A(7,7);
CHECK_A(7,8);
CHECK_A(7,9);
CHECK_A(8,0);
CHECK_A(8,1);
CHECK_A(8,2);
CHECK_A(8,3);
CHECK_A(8,4);
CHECK_A(8,5);
CHECK_A(8,6);
CHECK_A(8,7);
CHECK_A(8,8);
CHECK_A(8,9);
CHECK_A(9,0);
CHECK_A(9,1);
CHECK_A(9,2);
CHECK_A(9,3);
CHECK_A(9,4);
CHECK_A(9,5);
CHECK_A(9,6);
CHECK_A(9,7);
CHECK_A(9,8);
CHECK_A(9,9);
#undef CHECK_A
return boost::report_errors();
}

35
libs/qvm/test/access_q_fail.cpp Normal file
View File

@@ -0,0 +1,35 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_access.hpp>
#include <boost/qvm/vec_access.hpp>
struct my_quat { };
namespace
boost
{
namespace
qvm
{
template <>
struct
quat_traits<my_quat>
{
typedef int scalar_type;
template <int I> static int read_element( my_quat const & );
template <int I> static int & write_element( my_quat & );
};
}
}
int
main()
{
using namespace boost::qvm;
my_quat const q=my_quat();
A<3>(V(q));
return 1;
}

39
libs/qvm/test/access_q_test.cpp Normal file
View File

@@ -0,0 +1,39 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_access.hpp>
#include <boost/qvm/vec_access.hpp>
#include "test_qvm_quaternion.hpp"
int
main()
{
using namespace boost::qvm;
test_qvm::quaternion<Q1> q;
q.a[0]=42.0f;
q.a[1]=43.0f;
q.a[2]=44.0f;
q.a[3]=45.0f;
test_qvm::quaternion<Q1> const & qq=q;
BOOST_TEST_EQ(X(V(qq)),q.a[1]);
BOOST_TEST_EQ(Y(V(qq)),q.a[2]);
BOOST_TEST_EQ(Z(V(qq)),q.a[3]);
BOOST_TEST(&X(V(q))==&q.a[1]);
BOOST_TEST(&Y(V(q))==&q.a[2]);
BOOST_TEST(&Z(V(q))==&q.a[3]);
BOOST_TEST_EQ(S(qq),q.a[0]);
BOOST_TEST_EQ(X(qq),q.a[1]);
BOOST_TEST_EQ(Y(qq),q.a[2]);
BOOST_TEST_EQ(Z(qq),q.a[3]);
BOOST_TEST(&S(q)==&q.a[0]);
BOOST_TEST(&X(q)==&q.a[1]);
BOOST_TEST(&Y(q)==&q.a[2]);
BOOST_TEST(&Z(q)==&q.a[3]);
return boost::report_errors();
}

35
libs/qvm/test/access_v_fail1.cpp Normal file
View File

@@ -0,0 +1,35 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_access.hpp>
template <int D> struct my_vec { };
namespace
boost
{
namespace
qvm
{
template <int D>
struct
vec_traits< my_vec<D> >
{
typedef int scalar_type;
static int const dim=D;
template <int I> static int read_element( my_vec<D> const & );
template <int I> static int & write_element( my_vec<D> & );
};
}
}
int
main()
{
using namespace boost::qvm;
my_vec<1> const v=my_vec<1>();
A1(v);
return 1;
}

35
libs/qvm/test/access_v_fail2.cpp Normal file
View File

@@ -0,0 +1,35 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_access.hpp>
template <int D> struct my_vec { };
namespace
boost
{
namespace
qvm
{
template <int D>
struct
vec_traits< my_vec<D> >
{
typedef int scalar_type;
static int const dim=D;
template <int I> static int read_element( my_vec<D> const & );
template <int I> static int & write_element( my_vec<D> & );
};
}
}
int
main()
{
using namespace boost::qvm;
my_vec<1> v;
A1(v);
return 1;
}

40
libs/qvm/test/access_v_test.cpp Normal file
View File

@@ -0,0 +1,40 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_access.hpp>
#include "test_qvm_vector.hpp"
using namespace boost::qvm;
template <int I>
void
check_idx( test_qvm::vector<V1,10> & v, float & (*f)( test_qvm::vector<V1,10> & ) )
{
BOOST_TEST((&A<I>(v)==&v.a[I]));
BOOST_TEST((&f(v)==&v.a[I]));
}
int
main()
{
test_qvm::vector<V1,10> v;
#define CHECK_A(i) check_idx<i>(v,A##i);
CHECK_A(0);
CHECK_A(1);
CHECK_A(2);
CHECK_A(3);
CHECK_A(4);
CHECK_A(5);
CHECK_A(6);
CHECK_A(7);
CHECK_A(8);
CHECK_A(9);
#undef CHECK_A
BOOST_TEST(&A<0>(v)==&X(v));
BOOST_TEST(&A<1>(v)==&Y(v));
BOOST_TEST(&A<2>(v)==&Z(v));
BOOST_TEST(&A<3>(v)==&W(v));
return boost::report_errors();
}

70
libs/qvm/test/assign_test.cpp Normal file
View File

@@ -0,0 +1,70 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/mat_operations.hpp>
#include "test_qvm_matrix.hpp"
#include "test_qvm_quaternion.hpp"
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols>
void
test_matrix()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,Rows,Cols> const x(42,1);
test_qvm::matrix<M2,Rows,Cols> y(43,1);
assign(y,x);
BOOST_QVM_TEST_EQ(x.a,y.a);
}
template <int Dim>
void
test_vector()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> const x(42,1);
test_qvm::vector<V2,Dim> y(43,1);
assign(y,x);
BOOST_QVM_TEST_EQ(x.a,y.a);
}
void
test_quaternion()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> const x(42,1);
test_qvm::quaternion<Q2> y(43,1);
assign(y,x);
BOOST_QVM_TEST_EQ(x.a,y.a);
}
}
int
main()
{
test_matrix<1,2>();
test_matrix<2,1>();
test_matrix<2,2>();
test_matrix<1,3>();
test_matrix<3,1>();
test_matrix<3,3>();
test_matrix<1,4>();
test_matrix<4,1>();
test_matrix<4,4>();
test_matrix<1,5>();
test_matrix<5,1>();
test_matrix<5,5>();
test_vector<2>();
test_vector<3>();
test_vector<4>();
test_vector<5>();
test_quaternion();
return boost::report_errors();
}

54
libs/qvm/test/cmp_mm_test.cpp Normal file
View File

@@ -0,0 +1,54 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat_traits_array.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,Rows,Cols> const x(42,1);
for( int i=0; i!=Rows; ++i )
for( int j=0; j!=Cols; ++j )
{
{
test_qvm::matrix<M1,Rows,Cols> y(x);
BOOST_QVM_TEST_EQ(x,y);
y.a[i][j]=0;
BOOST_QVM_TEST_NEQ(x,y);
}
{
test_qvm::matrix<M2,Rows,Cols> y; assign(y,x);
BOOST_QVM_TEST_EQ(x,y);
y.a[i][j]=0;
BOOST_QVM_TEST_NEQ(x,y);
}
}
}
}
int
main()
{
test<1,2>();
test<2,1>();
test<2,2>();
test<1,3>();
test<3,1>();
test<3,3>();
test<1,4>();
test<4,1>();
test<4,4>();
test<1,5>();
test<5,1>();
test<5,5>();
return boost::report_errors();
}

35
libs/qvm/test/cmp_qq_test.cpp Normal file
View File

@@ -0,0 +1,35 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Qersion 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
#include <functional>
namespace
{
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> const x(42,1);
for( int i=0; i!=4; ++i )
{
{
test_qvm::quaternion<Q1> y(x);
BOOST_TEST(cmp(x,y,std::equal_to<float>()));
y.a[i]=0;
BOOST_TEST(!cmp(x,y,std::equal_to<float>()));
}
}
}
}
int
main()
{
test();
return boost::report_errors();
}

40
libs/qvm/test/cmp_vv_test.cpp Normal file
View File

@@ -0,0 +1,40 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/vec_traits_array.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
#include <functional>
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> const x(42,1);
for( int i=0; i!=Dim; ++i )
{
{
test_qvm::vector<V1,Dim> y(x);
BOOST_TEST(cmp(x,y,std::equal_to<float>()));
y.a[i]=0;
BOOST_TEST(!cmp(x,y,std::equal_to<float>()));
}
}
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

40
libs/qvm/test/col_mat_test.cpp Normal file
View File

@@ -0,0 +1,40 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/map.hpp>
#include <boost/qvm/mat_traits_array.hpp>
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm;
test_qvm::vector<V1,Dim> x(42,1);
float y[1][Dim]; assign(y,transposed(col_mat(x)));
BOOST_QVM_TEST_EQ(x.a,y[0]);
test_qvm::scalar_multiply_v(x.b,x.a,2.0f);
col<0>(col_mat(x)) *= 2;
BOOST_QVM_TEST_EQ(x.a,x.b);
col_mat(x)+col_mat(x);
-col_mat(x);
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

118
libs/qvm/test/col_test.cpp Normal file
View File

@@ -0,0 +1,118 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/map_mat_vec.hpp>
#include <boost/qvm/vec_traits_array.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/vec.hpp>
#include "test_qvm.hpp"
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols,int Col>
void
test()
{
using namespace boost::qvm;
test_qvm::matrix<M1,Rows,Cols> x(42,1);
float r1[Rows];
for( int i=0; i!=Rows; ++i )
r1[i]=x.a[i][Col];
float r2[Rows];
assign(r2,col<Col>(x));
BOOST_QVM_TEST_EQ(r1,r2);
col<Col>(x) *= 2;
for( int i=0; i!=Rows; ++i )
r1[i]=x.a[i][Col];
assign(r2,col<Col>(x));
BOOST_QVM_TEST_EQ(r1,r2);
col<Col>(x) + col<Col>(x);
-col<Col>(x);
}
}
int
main()
{
test<1,2,0>();
test<1,2,1>();
test<1,3,0>();
test<1,3,1>();
test<1,3,2>();
test<1,4,0>();
test<1,4,1>();
test<1,4,2>();
test<1,4,3>();
test<1,5,0>();
test<1,5,1>();
test<1,5,2>();
test<1,5,3>();
test<1,5,4>();
test<2,2,0>();
test<2,2,1>();
test<2,3,0>();
test<2,3,1>();
test<2,3,2>();
test<2,4,0>();
test<2,4,1>();
test<2,4,2>();
test<2,4,3>();
test<2,5,0>();
test<2,5,1>();
test<2,5,2>();
test<2,5,3>();
test<2,5,4>();
test<3,2,0>();
test<3,2,1>();
test<3,3,0>();
test<3,3,1>();
test<3,3,2>();
test<3,4,0>();
test<3,4,1>();
test<3,4,2>();
test<3,4,3>();
test<3,5,0>();
test<3,5,1>();
test<3,5,2>();
test<3,5,3>();
test<3,5,4>();
test<4,2,0>();
test<4,2,1>();
test<4,3,0>();
test<4,3,1>();
test<4,3,2>();
test<4,4,0>();
test<4,4,1>();
test<4,4,2>();
test<4,4,3>();
test<4,5,0>();
test<4,5,1>();
test<4,5,2>();
test<4,5,3>();
test<4,5,4>();
test<5,2,0>();
test<5,2,1>();
test<5,3,0>();
test<5,3,1>();
test<5,3,2>();
test<5,4,0>();
test<5,4,1>();
test<5,4,2>();
test<5,4,3>();
test<5,5,0>();
test<5,5,1>();
test<5,5,2>();
test<5,5,3>();
test<5,5,4>();
return boost::report_errors();
}

41
libs/qvm/test/conjugate_test.cpp Normal file
View File

@@ -0,0 +1,41 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/quat.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> const x(42,1);
test_qvm::scalar_multiply_v(x.b,x.a,-1.0f);
x.b[0]=-x.b[0];
test_same_type(x,conjugate(x));
{
test_qvm::quaternion<Q1> y=conjugate(x);
BOOST_QVM_TEST_EQ(x.b,y.a);
}
{
test_qvm::quaternion<Q1> y=conjugate(qref(x));
BOOST_QVM_TEST_EQ(x.b,y.a);
}
}
}
int
main()
{
test();
return boost::report_errors();
}

86
libs/qvm/test/convert_to_test.cpp Normal file
View File

@@ -0,0 +1,86 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/operations.hpp>
#include <boost/qvm/map_mat_mat.hpp>
#include "test_qvm_matrix.hpp"
#include "test_qvm_quaternion.hpp"
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols>
void
test_matrix()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,Rows,Cols> const x(42,1);
test_qvm::matrix<M2,Rows,Cols> const y=convert_to< test_qvm::matrix<M2,Rows,Cols> >(x);
BOOST_QVM_TEST_EQ(x.a,y.a);
}
template <int Dim>
void
test_vector()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> const x(42,1);
test_qvm::vector<V2,Dim> const y=convert_to< test_qvm::vector<V2,Dim> >(x);
BOOST_QVM_TEST_EQ(x.a,y.a);
}
void
test_quaternion()
{
using namespace boost::qvm;
test_qvm::quaternion<Q1> x(42,1);
normalize(x);
{
test_qvm::quaternion<Q2> const y=convert_to< test_qvm::quaternion<Q2> >(x);
BOOST_QVM_TEST_EQ(x.a,y.a);
}
{
test_qvm::matrix<M1,3,3> const my=convert_to< test_qvm::matrix<M1,3,3> >(x);
test_qvm::quaternion<Q1> const qy=convert_to< test_qvm::quaternion<Q1> >(my);
BOOST_QVM_TEST_CLOSE(x.a,qy.a,0.00001f);
}
{
test_qvm::matrix<M1,4,4> const my=convert_to< test_qvm::matrix<M1,4,4> >(x);
BOOST_TEST(my.a[0][3]==0);
BOOST_TEST(my.a[1][3]==0);
BOOST_TEST(my.a[2][3]==0);
BOOST_TEST(my.a[3][0]==0);
BOOST_TEST(my.a[3][1]==0);
BOOST_TEST(my.a[3][2]==0);
BOOST_TEST(my.a[3][3]==1);
test_qvm::quaternion<Q1> const qy=convert_to< test_qvm::quaternion<Q1> >(del_row_col<3,3>(my));
BOOST_QVM_TEST_CLOSE(x.a,qy.a,0.00001f);
}
}
}
int
main()
{
test_matrix<1,2>();
test_matrix<2,1>();
test_matrix<2,2>();
test_matrix<1,3>();
test_matrix<3,1>();
test_matrix<3,3>();
test_matrix<1,4>();
test_matrix<4,1>();
test_matrix<4,4>();
test_matrix<1,5>();
test_matrix<5,1>();
test_matrix<5,5>();
test_quaternion();
test_vector<2>();
test_vector<3>();
test_vector<4>();
test_vector<5>();
return boost::report_errors();
}

56
libs/qvm/test/cross_test.cpp Normal file
View File

@@ -0,0 +1,56 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/vec_access.hpp>
#include <boost/qvm/mat_access.hpp>
#include <boost/qvm/vec_operations3.hpp>
#include <boost/qvm/vec.hpp>
//#include <boost/qvm/quat_traits.hpp>
#include "test_qvm_vector.hpp"
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
}
int
main()
{
using namespace boost::qvm;
test_qvm::vector<V1,3> x(42,1);
test_qvm::vector<V1,3> y=x*2;
test_qvm::matrix<M1,3,3> m;
A00(m) = 0;
A01(m) = -A2(x);
A02(m) = A1(x);
A10(m) = A2(x);
A11(m) = 0;
A12(m) = -A0(x);
A20(m) = -A1(x);
A21(m) = A0(x);
A22(m) = 0;
{
test_same_type(x,cross(x,y));
test_qvm::vector<V1,3> c=cross(x,y);
test_qvm::multiply_mv(c.b,m.a,y.a);
BOOST_QVM_TEST_EQ(c.a,c.b);
}
{
test_qvm::vector<V2,3> c=cross(vref(x),y);
test_qvm::multiply_mv(c.b,m.a,y.a);
BOOST_QVM_TEST_EQ(c.a,c.b);
}
{
test_qvm::vector<V2,3> c=cross(x,vref(y));
test_qvm::multiply_mv(c.b,m.a,y.a);
BOOST_QVM_TEST_EQ(c.a,c.b);
}
return boost::report_errors();
}

51
libs/qvm/test/deduce_matrix_test.cpp Normal file
View File

@@ -0,0 +1,51 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/deduce_mat.hpp>
template <class T,class U>
struct same_type;
template <class T>
struct
same_type<T,T>
{
};
template <class A,class B,int R,int C,class Result>
struct
check
{
same_type<typename boost::qvm::deduce_mat2<A,B,R,C>::type,Result> a;
same_type<typename boost::qvm::deduce_mat2<B,A,R,C>::type,Result> b;
};
template <class T,int R,int C> struct m;
namespace
boost
{
namespace
qvm
{
template <class T,int R,int C>
struct
mat_traits< m<T,R,C> >
{
typedef T scalar_type;
static int const rows=R;
static int const cols=C;
};
}
}
int
main()
{
same_type< boost::qvm::deduce_mat< m<int,4,2> >::type, m<int,4,2> >();
same_type< boost::qvm::deduce_mat< m<int,4,2>, 4, 4 >::type, boost::qvm::mat<int,4,4> >();
check< m<int,4,2>, m<int,4,2>, 4, 2, m<int,4,2> >();
check< m<int,4,2>, m<float,4,2>, 4, 4, boost::qvm::mat<float,4,4> >();
}

8
libs/qvm/test/deduce_scalar_fail1.cpp Normal file
View File

@@ -0,0 +1,8 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/deduce_scalar.hpp>
typedef boost::qvm::deduce_scalar<char,int>::type char_scalars_not_supported_use_signed_char_instead;

9
libs/qvm/test/deduce_scalar_fail2.cpp Normal file
View File

@@ -0,0 +1,9 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/deduce_scalar.hpp>
struct foo;
typedef boost::qvm::deduce_scalar<foo,int>::type user_defined_types_require_specialization;

10
libs/qvm/test/deduce_scalar_fail3.cpp Normal file
View File

@@ -0,0 +1,10 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/deduce_scalar.hpp>
struct foo;
struct bar;
typedef boost::qvm::deduce_scalar<foo,bar>::type user_defined_types_require_specialization;

77
libs/qvm/test/deduce_scalar_test.cpp Normal file
View File

@@ -0,0 +1,77 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/deduce_scalar.hpp>
template <class T,class U>
struct same_type;
template <class T>
struct
same_type<T,T>
{
};
template <class A,class B,class R>
struct
check
{
same_type<typename boost::qvm::deduce_scalar<A,B>::type,R> a;
same_type<typename boost::qvm::deduce_scalar<B,A>::type,R> b;
};
int
main()
{
check<signed char,signed char,signed char>();
check<signed char,signed short,signed short>();
check<signed char,signed int,signed int>();
check<signed char,signed long,signed long>();
check<signed char,unsigned char,unsigned char>();
check<signed char,unsigned short,unsigned short>();
check<signed char,unsigned int,unsigned int>();
check<signed char,unsigned long,unsigned long>();
check<signed char,float,float>();
check<signed char,double,double>();
check<signed short,signed short,signed short>();
check<signed short,signed int,signed int>();
check<signed short,signed long,signed long>();
check<signed short,unsigned short,unsigned short>();
check<signed short,unsigned int,unsigned int>();
check<signed short,unsigned long,unsigned long>();
check<signed short,float,float>();
check<signed short,double,double>();
check<signed int,signed int,signed int>();
check<signed int,signed long,signed long>();
check<signed int,unsigned int,unsigned int>();
check<signed int,unsigned long,unsigned long>();
check<signed int,float,float>();
check<signed int,double,double>();
check<signed long,signed long,signed long>();
check<signed long,unsigned long,unsigned long>();
check<signed long,float,float>();
check<signed long,double,double>();
check<unsigned char,unsigned char,unsigned char>();
check<unsigned char,unsigned short,unsigned short>();
check<unsigned char,unsigned int,unsigned int>();
check<unsigned char,unsigned long,unsigned long>();
check<unsigned char,float,float>();
check<unsigned char,double,double>();
check<unsigned short,unsigned short,unsigned short>();
check<unsigned short,unsigned int,unsigned int>();
check<unsigned short,unsigned long,unsigned long>();
check<unsigned short,float,float>();
check<unsigned short,double,double>();
check<unsigned int,unsigned int,unsigned int>();
check<unsigned int,unsigned long,unsigned long>();
check<unsigned int,float,float>();
check<unsigned int,double,double>();
check<unsigned long,unsigned long,unsigned long>();
check<unsigned long,float,float>();
check<unsigned long,double,double>();
check<float,float,float>();
check<float,double,double>();
check<double,double,double>();
}

50
libs/qvm/test/deduce_vector_test.cpp Normal file
View File

@@ -0,0 +1,50 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/deduce_vec.hpp>
template <class T,class U>
struct same_type;
template <class T>
struct
same_type<T,T>
{
};
template <class A,class B,int D,class Result>
struct
check
{
same_type<typename boost::qvm::deduce_vec2<A,B,D>::type,Result> a;
same_type<typename boost::qvm::deduce_vec2<B,A,D>::type,Result> b;
};
template <class T,int D> struct v;
namespace
boost
{
namespace
qvm
{
template <class T,int D>
struct
vec_traits< v<T,D> >
{
typedef T scalar_type;
static int const dim=D;
};
}
}
int
main()
{
same_type< boost::qvm::deduce_vec< v<int,3> >::type, v<int,3> >();
same_type< boost::qvm::deduce_vec< v<int,3>, 4 >::type, boost::qvm::vec<int,4> >();
check< v<int,3>, v<int,3>, 3, v<int,3> >();
check< v<int,3>, v<float,3>, 4, boost::qvm::vec<float,4> >();
}

61
libs/qvm/test/del_col_test.cpp Normal file
View File

@@ -0,0 +1,61 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/map_mat_mat.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat_traits_array.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm.hpp"
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols,int Col>
void
test()
{
using namespace boost::qvm;
test_qvm::matrix<M1,Rows,Cols> x(42,1);
float r1[Rows][Cols-1];
for( int i=0; i!=Rows; ++i )
for( int j=0; j!=Cols-1; ++j )
r1[i][j]=x.a[i][j+(j>=Col)];
float r2[Rows][Cols-1];
assign(r2,del_col<Col>(x));
BOOST_QVM_TEST_EQ(r1,r2);
del_col<Col>(x) *= 2;
for( int i=0; i!=Rows; ++i )
for( int j=0; j!=Cols-1; ++j )
r1[i][j]=x.a[i][j+(j>=Col)];
assign(r2,del_col<Col>(x));
BOOST_QVM_TEST_EQ(r1,r2);
del_col<Col>(x) + del_col<Col>(x);
-del_col<Col>(x);
}
}
int
main()
{
test<2,2,0>();
test<2,2,1>();
test<3,3,0>();
test<3,3,1>();
test<3,3,2>();
test<4,4,0>();
test<4,4,1>();
test<4,4,2>();
test<4,4,3>();
test<5,5,0>();
test<5,5,1>();
test<5,5,2>();
test<5,5,3>();
test<5,5,4>();
return boost::report_errors();
}

101
libs/qvm/test/del_row_col_test.cpp Normal file
View File

@@ -0,0 +1,101 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/map_mat_mat.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat_traits_array.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm.hpp"
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols,int Row,int Col>
void
test()
{
using namespace boost::qvm;
test_qvm::matrix<M1,Rows,Cols> x(42,1);
float r1[Rows-1][Cols-1];
for( int i=0; i!=Rows-1; ++i )
for( int j=0; j!=Cols-1; ++j )
r1[i][j]=x.a[i+(i>=Row)][j+(j>=Col)];
float r2[Rows-1][Cols-1];
assign(r2,del_row_col<Row,Col>(x));
BOOST_QVM_TEST_EQ(r1,r2);
del_row_col<Row,Col>(x) *= 2;
for( int i=0; i!=Rows-1; ++i )
for( int j=0; j!=Cols-1; ++j )
r1[i][j]=x.a[i+(i>=Row)][j+(j>=Col)];
assign(r2,del_row_col<Row,Col>(x));
BOOST_QVM_TEST_EQ(r1,r2);
del_row_col<Row,Col>(x) + del_row_col<Row,Col>(x);
-del_row_col<Row,Col>(x);
}
}
int
main()
{
test<2,2,0,0>();
test<2,2,0,1>();
test<2,2,1,0>();
test<2,2,1,1>();
test<3,3,0,0>();
test<3,3,0,1>();
test<3,3,0,2>();
test<3,3,1,0>();
test<3,3,1,1>();
test<3,3,1,2>();
test<3,3,2,0>();
test<3,3,2,1>();
test<3,3,2,2>();
test<4,4,0,0>();
test<4,4,0,1>();
test<4,4,0,2>();
test<4,4,0,3>();
test<4,4,1,0>();
test<4,4,1,1>();
test<4,4,1,2>();
test<4,4,1,3>();
test<4,4,2,0>();
test<4,4,2,1>();
test<4,4,2,2>();
test<4,4,2,3>();
test<4,4,3,0>();
test<4,4,3,1>();
test<4,4,3,2>();
test<4,4,3,3>();
test<5,5,0,0>();
test<5,5,0,1>();
test<5,5,0,2>();
test<5,5,0,3>();
test<5,5,0,4>();
test<5,5,1,0>();
test<5,5,1,1>();
test<5,5,1,2>();
test<5,5,1,3>();
test<5,5,1,4>();
test<5,5,2,0>();
test<5,5,2,1>();
test<5,5,2,2>();
test<5,5,2,3>();
test<5,5,2,4>();
test<5,5,3,0>();
test<5,5,3,1>();
test<5,5,3,2>();
test<5,5,3,3>();
test<5,5,3,4>();
test<5,5,4,0>();
test<5,5,4,1>();
test<5,5,4,2>();
test<5,5,4,3>();
test<5,5,4,4>();
return boost::report_errors();
}

61
libs/qvm/test/del_row_test.cpp Normal file
View File

@@ -0,0 +1,61 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/map_mat_mat.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat_traits_array.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm.hpp"
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols,int Row>
void
test()
{
using namespace boost::qvm;
test_qvm::matrix<M1,Rows,Cols> x(42,1);
float r1[Rows-1][Cols];
for( int i=0; i!=Rows-1; ++i )
for( int j=0; j!=Cols; ++j )
r1[i][j]=x.a[i+(i>=Row)][j];
float r2[Rows-1][Cols];
assign(r2,del_row<Row>(x));
BOOST_QVM_TEST_EQ(r1,r2);
del_row<Row>(x) *= 2;
for( int i=0; i!=Rows-1; ++i )
for( int j=0; j!=Cols; ++j )
r1[i][j]=x.a[i+(i>=Row)][j];
assign(r2,del_row<Row>(x));
BOOST_QVM_TEST_EQ(r1,r2);
del_row<Row>(x)+del_row<Row>(x);
-del_row<Row>(x);
}
}
int
main()
{
test<2,2,0>();
test<2,2,1>();
test<3,3,0>();
test<3,3,1>();
test<3,3,2>();
test<4,4,0>();
test<4,4,1>();
test<4,4,2>();
test<4,4,3>();
test<5,5,0>();
test<5,5,1>();
test<5,5,2>();
test<5,5,3>();
test<5,5,4>();
return boost::report_errors();
}

32
libs/qvm/test/determinant_test.cpp Normal file
View File

@@ -0,0 +1,32 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int D>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,D,D> const x(42,1);
float gd=test_qvm::determinant(x.b);
float d=determinant(x);
BOOST_QVM_TEST_EQ(gd,d);
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

42
libs/qvm/test/diag_mat_test.cpp Normal file
View File

@@ -0,0 +1,42 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/map.hpp>
#include <boost/qvm/mat_traits_array.hpp>
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm;
test_qvm::vector<V1,Dim> x(42,1);
float y[Dim][Dim]; assign(y,diag_mat(x));
for( int i=0; i!=Dim; ++i )
x.b[i]=y[i][i];
BOOST_QVM_TEST_EQ(x.a,x.b);
test_qvm::scalar_multiply_v(x.b,x.a,2.0f);
diag(diag_mat(x)) *= 2;
BOOST_QVM_TEST_EQ(x.a,x.b);
diag_mat(x) + diag_mat(x);
-diag_mat(x);
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

65
libs/qvm/test/diag_test.cpp Normal file
View File

@@ -0,0 +1,65 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/vec.hpp>
#include <boost/qvm/map_mat_vec.hpp>
#include "test_qvm_matrix.hpp"
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <int A,int B,bool LessThan=(A<B)>
struct
get_min
{
static int const value=B;
};
template <int A,int B>
struct
get_min<A,B,true>
{
static int const value=A;
};
template <int Rows,int Cols>
void
test()
{
using namespace boost::qvm;
int const D=get_min<Rows,Cols>::value;
test_qvm::matrix<M1,Rows,Cols> x(42,1);
test_qvm::vector<V1,D> y=diag(x);
for( int i=0; i!=D; ++i )
y.b[i]=x.a[i][i];
BOOST_QVM_TEST_EQ(y.a,y.b);
diag(x) *= 2;
for( int i=0; i!=D; ++i )
x.b[i][i] *= 2;
BOOST_QVM_TEST_EQ(x.a,x.b);
diag(x) + diag(x);
-diag(x);
}
}
int
main()
{
test<1,2>();
test<1,3>();
test<1,4>();
test<1,5>();
test<2,1>();
test<3,1>();
test<4,1>();
test<5,1>();
test<2,2>();
test<3,3>();
test<4,4>();
test<5,5>();
return boost::report_errors();
}

40
libs/qvm/test/div_eq_ms_test.cpp Normal file
View File

@@ -0,0 +1,40 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,Rows,Cols> x(42,1);
test_qvm::scalar_multiply_m(x.b,x.a,0.5f);
x/=2;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
}
int
main()
{
test<1,2>();
test<2,1>();
test<2,2>();
test<1,3>();
test<3,1>();
test<3,3>();
test<1,4>();
test<4,1>();
test<4,4>();
test<1,5>();
test<5,1>();
test<5,5>();
return boost::report_errors();
}

28
libs/qvm/test/div_eq_qs_test.cpp Normal file
View File

@@ -0,0 +1,28 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> x(42,1);
test_qvm::scalar_multiply_v(x.b,x.a,0.5f);
x/=2;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
}
int
main()
{
test();
return boost::report_errors();
}

33
libs/qvm/test/div_eq_vs_test.cpp Normal file
View File

@@ -0,0 +1,33 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> x(42,1);
test_qvm::scalar_multiply_v(x.b,x.a,0.5f);
x/=2;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
}
int
main()
{
test<1>();
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

52
libs/qvm/test/div_ms_test.cpp Normal file
View File

@@ -0,0 +1,52 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int Rows,int Cols>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,Rows,Cols> const x(42,1);
test_qvm::scalar_multiply_m(x.b,x.a,0.5f);
test_same_type(x,x/2);
{
test_qvm::matrix<M1,Rows,Cols> y=x/2;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
{
test_qvm::matrix<M1,Rows,Cols> y=mref(x)/2;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
}
}
int
main()
{
test<1,2>();
test<2,1>();
test<2,2>();
test<1,3>();
test<3,1>();
test<3,3>();
test<1,4>();
test<4,1>();
test<4,4>();
test<1,5>();
test<5,1>();
test<5,5>();
return boost::report_errors();
}

40
libs/qvm/test/div_qs_test.cpp Normal file
View File

@@ -0,0 +1,40 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/quat.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> const x(42,1);
test_qvm::scalar_multiply_v(x.b,x.a,0.5f);
test_same_type(x,x/2);
{
test_qvm::quaternion<Q1> y=x/2;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
{
test_qvm::quaternion<Q1> y=qref(x)/2;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
}
}
int
main()
{
test();
return boost::report_errors();
}

45
libs/qvm/test/div_vs_test.cpp Normal file
View File

@@ -0,0 +1,45 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/vec.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> const x(42,1);
test_qvm::scalar_multiply_v(x.b,x.a,0.5f);
test_same_type(x,x/2);
{
test_qvm::vector<V1,Dim> y=x/2;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
{
test_qvm::vector<V1,Dim> y=vref(x)/2;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
}
}
int
main()
{
test<1>();
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

44
libs/qvm/test/dot_qq_test.cpp Normal file
View File

@@ -0,0 +1,44 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> const x(42,1);
{
test_qvm::quaternion<Q1> const y(43,1);
test_same_type(float(),dot(x,y));
float d1=dot(x,y);
float d2=test_qvm::dot<float>(x.a,y.a);
BOOST_QVM_TEST_CLOSE(d1,d2,0.000001f);
}
{
test_qvm::quaternion<Q1,double> const y(43,1);
test_same_type(double(),dot(x,y));
double d1=dot(x,y);
double d2=test_qvm::dot<double>(x.a,y.a);
BOOST_QVM_TEST_CLOSE(d1,d2,0.000001);
}
}
}
int
main()
{
test();
return boost::report_errors();
}

48
libs/qvm/test/dot_vv_test.cpp Normal file
View File

@@ -0,0 +1,48 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> const x(42,1);
{
test_qvm::vector<V1,Dim> const y(43,1);
test_same_type(float(),dot(x,y));
float d1=dot(x,y);
float d2=test_qvm::dot<float>(x.a,y.a);
BOOST_QVM_TEST_CLOSE(d1,d2,0.000001f);
}
{
test_qvm::vector<V1,Dim,double> const y(43,1);
test_same_type(double(),dot(x,y));
double d1=dot(x,y);
double d2=test_qvm::dot<double>(x.a,y.a);
BOOST_QVM_TEST_CLOSE(d1,d2,0.000001);
}
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

53
libs/qvm/test/eq_mm_test.cpp Normal file
View File

@@ -0,0 +1,53 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,Rows,Cols> const x(42,1);
for( int i=0; i!=Rows; ++i )
for( int j=0; j!=Cols; ++j )
{
{
test_qvm::matrix<M1,Rows,Cols> y(x);
BOOST_QVM_TEST_EQ(x,y);
y.a[i][j]=0;
BOOST_QVM_TEST_NEQ(x,y);
}
{
test_qvm::matrix<M2,Rows,Cols> y; assign(y,x);
BOOST_QVM_TEST_EQ(x,y);
y.a[i][j]=0;
BOOST_QVM_TEST_NEQ(x,y);
}
}
}
}
int
main()
{
test<1,2>();
test<2,1>();
test<2,2>();
test<1,3>();
test<3,1>();
test<3,3>();
test<1,4>();
test<4,1>();
test<4,4>();
test<1,5>();
test<5,1>();
test<5,5>();
return boost::report_errors();
}

40
libs/qvm/test/eq_qq_test.cpp Normal file
View File

@@ -0,0 +1,40 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Qersion 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> const x(42,1);
for( int i=0; i!=4; ++i )
{
{
test_qvm::quaternion<Q1> y(x);
BOOST_QVM_TEST_EQ(x,y);
y.a[i]=0;
BOOST_QVM_TEST_NEQ(x,y);
}
{
test_qvm::quaternion<Q2> y; assign(y,x);
BOOST_QVM_TEST_EQ(x,y);
y.a[i]=0;
BOOST_QVM_TEST_NEQ(x,y);
}
}
}
}
int
main()
{
test();
return boost::report_errors();
}

44
libs/qvm/test/eq_vv_test.cpp Normal file
View File

@@ -0,0 +1,44 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> const x(42,1);
for( int i=0; i!=Dim; ++i )
{
{
test_qvm::vector<V1,Dim> y(x);
BOOST_QVM_TEST_EQ(x,y);
y.a[i]=0;
BOOST_QVM_TEST_NEQ(x,y);
}
{
test_qvm::vector<V2,Dim> y; assign(y,x);
BOOST_QVM_TEST_EQ(x,y);
y.a[i]=0;
BOOST_QVM_TEST_NEQ(x,y);
}
}
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

439
libs/qvm/test/gold.hpp Normal file
View File

@@ -0,0 +1,439 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef UUID_907229FCB3A711DE83C152F855D89593
#define UUID_907229FCB3A711DE83C152F855D89593
#include <limits>
#include <math.h>
#include <assert.h>
#include <memory.h>
#include <stdlib.h>
namespace
test_qvm
{
namespace
detail
{
inline
float
sin( float a )
{
return ::sinf(a);
}
inline
double
sin( double a )
{
return ::sin(a);
}
inline
float
cos( float a )
{
return ::cosf(a);
}
inline
double
cos( double a )
{
return ::cos(a);
}
inline
float
abs( float a )
{
return ::fabsf(a);
}
inline
double
abs( double a )
{
return ::fabs(a);
}
inline
float
atan2( float a, float b )
{
return ::atan2f(a,b);
}
inline
double
atan2( double a, double b )
{
return ::atan2(a,b);
}
template <class T>
T
determinant( T * * a, int n )
{
int i,j,j1,j2;
T det = 0;
T * * m = 0;
assert(n>=1);
if( n==1 )
det = a[0][0];
else if( n==2 )
det = a[0][0] * a[1][1] - a[1][0] * a[0][1];
else
{
det = 0;
for( j1=0; j1<n; j1++ )
{
m = static_cast<T * *>(malloc((n-1)*sizeof(T *)));
for( i=0; i<n-1; i++ )
m[i] = static_cast<T *>(malloc((n-1)*sizeof(T)));
for( i=1; i<n; i++ )
{
j2 = 0;
for( j=0; j<n; j++ )
{
if( j==j1 )
continue;
m[i-1][j2] = a[i][j];
j2++;
}
}
det += T(pow(-1.0,1.0+j1+1.0)) * a[0][j1] * determinant(m,n-1);
for( i=0; i<n-1; i++ )
free(m[i]);
free(m);
}
}
return(det);
}
template <class T,int N>
void
cofactor( T * * a, T (&b)[N][N] )
{
int i,j,ii,jj,i1,j1;
T det;
T * * c;
c = static_cast<T * *>(malloc((N-1)*sizeof(T *)));
for( i=0; i<N-1; i++ )
c[i] = static_cast<T *>(malloc((N-1)*sizeof(T)));
for( j=0; j<N; j++ )
{
for( i=0; i<N; i++ )
{
i1 = 0;
for( ii=0; ii<N; ii++ )
{
if( ii==i )
continue;
j1 = 0;
for( jj=0; jj<N; jj++ )
{
if( jj==j )
continue;
c[i1][j1] = a[ii][jj];
j1++;
}
i1++;
}
det = determinant(c,N-1);
b[i][j] = T(pow(-1.0,i+j+2.0)) * det;
}
}
for( i=0; i<N-1; i++ )
free(c[i]);
free(c);
}
}
template <class T,int D>
T
determinant( T (&in)[D][D] )
{
T * * m = static_cast<T * *>(malloc(D*sizeof(T *)));
for( int i=0; i!=D; ++i )
{
m[i] = static_cast<T *>(malloc(D*sizeof(T)));
for( int j=0; j!=D; ++j )
m[i][j]=in[i][j];
}
T det=::test_qvm::detail::determinant(m,D);
for( int i=0; i<D; ++i )
free(m[i]);
free(m);
return det;
}
template <class T,int D>
void
inverse( T (&out)[D][D], T (&in)[D][D] )
{
T * * m = static_cast<T * *>(malloc(D*sizeof(T *)));
for( int i=0; i!=D; ++i )
{
m[i] = static_cast<T *>(malloc(D*sizeof(T)));
for( int j=0; j!=D; ++j )
m[i][j]=in[i][j];
}
T det=::test_qvm::detail::determinant(m,D);
assert(det!=T(0));
T f=T(1)/det;
T b[D][D];
::test_qvm::detail::cofactor(m,b);
for( int i=0; i<D; ++i )
free(m[i]);
free(m);
for( int i=0; i!=D; ++i )
for( int j=0; j!=D; ++j )
out[j][i]=b[i][j]*f;
}
template <class T,int M,int N>
void
init_m( T (&r)[M][N], T start=T(0), T step=T(0) )
{
for( int i=0; i<M; ++i )
for( int j=0; j<N; ++j,start+=step )
r[i][j] = start;
}
template <class T,int D>
void
init_v( T (&r)[D], T start=T(0), T step=T(0) )
{
for( int i=0; i<D; ++i,start+=step )
r[i] = start;
}
template <class T,int M,int N>
void
zero_mat( T (&r)[M][N] )
{
for( int i=0; i<M; ++i )
for( int j=0; j<N; ++j )
r[i][j] = T(0);
}
template <class T,int D>
void
zero_vec( T (&r)[D] )
{
for( int i=0; i<D; ++i )
r[i] = T(0);
}
template <class T,int D>
void
identity( T (&r)[D][D] )
{
for( int i=0; i<D; ++i )
for( int j=0; j<D; ++j )
r[i][j] = (i==j) ? T(1) : T(0);
}
template <class T,class U,class V,int M,int N>
void
add_m( T (&r)[M][N], U (&a)[M][N], V (&b)[M][N] )
{
for( int i=0; i<M; ++i )
for( int j=0; j<N; ++j )
r[i][j] = a[i][j] + b[i][j];
}
template <class T,class U,class V,int D>
void
add_v( T (&r)[D], U (&a)[D], V (&b)[D] )
{
for( int i=0; i<D; ++i )
r[i] = a[i] + b[i];
}
template <class T,class U,class V,int M,int N>
void
subtract_m( T (&r)[M][N], U (&a)[M][N], V (&b)[M][N] )
{
for( int i=0; i<M; ++i )
for( int j=0; j<N; ++j )
r[i][j] = a[i][j] - b[i][j];
}
template <class T,class U,class V,int D>
void
subtract_v( T (&r)[D], U (&a)[D], V (&b)[D] )
{
for( int i=0; i<D; ++i )
r[i] = a[i] - b[i];
}
template <class T,int D,class U>
void
rotation_x( T (&r)[D][D], U angle )
{
identity(r);
T c=::test_qvm::detail::cos(angle);
T s=::test_qvm::detail::sin(angle);
r[1][1]=c;
r[1][2]=-s;
r[2][1]=s;
r[2][2]=c;
}
template <class T,int D,class U>
void
rotation_y( T (&r)[D][D], U angle )
{
identity(r);
T c=::test_qvm::detail::cos(angle);
T s=::test_qvm::detail::sin(angle);
r[0][0]=c;
r[0][2]=s;
r[2][0]=-s;
r[2][2]=c;
}
template <class T,int D,class U>
void
rotation_z( T (&r)[D][D], U angle )
{
identity(r);
T c=::test_qvm::detail::cos(angle);
T s=::test_qvm::detail::sin(angle);
r[0][0]=c;
r[0][1]=-s;
r[1][0]=s;
r[1][1]=c;
}
template <class T,int D>
void
translation( T (&r)[D][D], T (&t)[D-1] )
{
identity(r);
for( int i=0; i!=D-1; ++i )
r[i][D-1]=t[i];
}
template <class R,class T,class U,int M,int N,int P>
void
multiply_m( R (&r)[M][P], T (&a)[M][N], U (&b)[N][P] )
{
for( int i=0; i<M; ++i )
for( int j=0; j<P; ++j )
{
R x=0;
for( int k=0; k<N; ++k )
x += R(a[i][k])*R(b[k][j]);
r[i][j] = x;
}
}
template <class R,class T,class U,int M,int N>
void
multiply_mv( R (&r)[M], T (&a)[M][N], U (&b)[N] )
{
for( int i=0; i<M; ++i )
{
R x=0;
for( int k=0; k<N; ++k )
x += R(a[i][k])*R(b[k]);
r[i] = x;
}
}
template <class R,class T,class U,int N,int P>
void
multiply_vm( R (&r)[P], T (&a)[N], U (&b)[N][P] )
{
for( int j=0; j<P; ++j )
{
R x=0;
for( int k=0; k<N; ++k )
x += R(a[k])*R(b[k][j]);
r[j] = x;
}
}
template <class T,class U,int M,int N,class S>
void
scalar_multiply_m( T (&r)[M][N], U (&a)[M][N], S scalar )
{
for( int i=0; i<M; ++i )
for( int j=0; j<N; ++j )
r[i][j] = a[i][j]*scalar;
}
template <class T,class U,int D,class S>
void
scalar_multiply_v( T (&r)[D], U (&a)[D], S scalar )
{
for( int i=0; i<D; ++i )
r[i] = a[i]*scalar;
}
template <class T,int M,int N>
void
transpose( T (&r)[M][N], T (&a)[N][M] )
{
for( int i=0; i<M; ++i )
for( int j=0; j<N; ++j )
r[i][j] = a[j][i];
}
template <class R,class T,class U,int D>
R
dot( T (&a)[D], U (&b)[D] )
{
R r=R(0);
for( int i=0; i<D; ++i )
r+=a[i]*b[i];
return r;
}
template <class T,int M,int N>
T
norm_squared( T (&m)[M][N] )
{
T f=T(0);
for( int i=0; i<M; ++i )
for( int j=0; j<N; ++j )
{
T x=m[i][j];
f+=x*x;
}
return f;
}
template <class T>
inline
void
matrix_perspective_lh( T (&r)[4][4], T fov_y, T aspect_ratio, T zn, T zf )
{
T ys=T(1)/::tanf(fov_y/T(2));
T xs=ys/aspect_ratio;
zero_mat(r);
r[0][0] = xs;
r[1][1] = ys;
r[2][2] = zf/(zf-zn);
r[2][3] = -zn*zf/(zf-zn);
r[3][2] = 1;
}
template <class T>
inline
void
matrix_perspective_rh( T (&r)[4][4], T fov_y, T aspect_ratio, T zn, T zf )
{
matrix_perspective_lh(r,fov_y,aspect_ratio,zn,zf);
r[2][2]=-r[2][2];
r[3][2]=-r[3][2];
}
}
#endif

7
libs/qvm/test/header-test.cpp Normal file
View File

@@ -0,0 +1,7 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include REVERGE_HEADER
#include REVERGE_HEADER

36
libs/qvm/test/identity_mat_test.cpp Normal file
View File

@@ -0,0 +1,36 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include "test_qvm_matrix.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm;
test_qvm::matrix<M1,Dim,Dim> m=identity_mat<float,Dim>();
for( int i=0; i!=Dim; ++i )
for( int j=0; j!=Dim; ++j )
BOOST_TEST(m.a[i][j]==float(i==j));
test_qvm::matrix<M2,Dim,Dim> n(42,1);
set_identity(n);
for( int i=0; i!=Dim; ++i )
for( int j=0; j!=Dim; ++j )
BOOST_TEST(n.a[i][j]==float(i==j));
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

34
libs/qvm/test/identity_quat_test.cpp Normal file
View File

@@ -0,0 +1,34 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include "test_qvm_quaternion.hpp"
namespace
{
void
test()
{
using namespace boost::qvm;
test_qvm::quaternion<Q1> q=identity_quat<float>();
BOOST_TEST(q.a[0]==1);
BOOST_TEST(q.a[1]==0);
BOOST_TEST(q.a[2]==0);
BOOST_TEST(q.a[3]==0);
test_qvm::quaternion<Q2> p(42,1);
set_identity(p);
BOOST_TEST(p.a[0]==1);
BOOST_TEST(p.a[1]==0);
BOOST_TEST(p.a[2]==0);
BOOST_TEST(p.a[3]==0);
}
}
int
main()
{
test();
return boost::report_errors();
}

435
libs/qvm/test/interop_test.cpp Normal file
View File

@@ -0,0 +1,435 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/operations.hpp>
#include <boost/qvm/quat.hpp>
#include <boost/qvm/vec.hpp>
#include <boost/qvm/mat.hpp>
namespace
my_stuff
{
struct
mat
{
float a[3][3];
};
struct
vec
{
float a[3];
};
struct
quat
{
float a[4];
};
}
namespace
boost
{
namespace
qvm
{
template <>
struct
mat_traits<my_stuff::mat>
{
typedef float scalar_type;
static int const rows=3;
static int const cols=3;
template <int R,int C>
static
scalar_type &
write_element( my_stuff::mat & m )
{
BOOST_QVM_STATIC_ASSERT(R>=0);
BOOST_QVM_STATIC_ASSERT(R<rows);
BOOST_QVM_STATIC_ASSERT(C>=0);
BOOST_QVM_STATIC_ASSERT(C<cols);
return m.a[R][C];
}
template <int R,int C>
static
scalar_type
read_element( my_stuff::mat const & m )
{
BOOST_QVM_STATIC_ASSERT(R>=0);
BOOST_QVM_STATIC_ASSERT(R<rows);
BOOST_QVM_STATIC_ASSERT(C>=0);
BOOST_QVM_STATIC_ASSERT(C<cols);
return m.a[R][C];
}
static
inline
scalar_type &
write_element_idx( int r, int c, my_stuff::mat & m )
{
BOOST_QVM_ASSERT(r>=0);
BOOST_QVM_ASSERT(r<rows);
BOOST_QVM_ASSERT(c>=0);
BOOST_QVM_ASSERT(c<cols);
return m.a[r][c];
}
static
inline
scalar_type
read_element_idx( int r, int c, my_stuff::mat const & m )
{
BOOST_QVM_ASSERT(r>=0);
BOOST_QVM_ASSERT(r<rows);
BOOST_QVM_ASSERT(c>=0);
BOOST_QVM_ASSERT(c<cols);
return m.a[r][c];
}
};
template <>
struct
vec_traits<my_stuff::vec>
{
static int const dim=3;
typedef float scalar_type;
template <int I>
static
scalar_type &
write_element( my_stuff::vec & m )
{
BOOST_QVM_STATIC_ASSERT(I>=0);
BOOST_QVM_STATIC_ASSERT(I<dim);
return m.a[I];
}
template <int I>
static
scalar_type
read_element( my_stuff::vec const & m )
{
BOOST_QVM_STATIC_ASSERT(I>=0);
BOOST_QVM_STATIC_ASSERT(I<dim);
return m.a[I];
}
static
inline
scalar_type &
write_element_idx( int i, my_stuff::vec & m )
{
BOOST_QVM_ASSERT(i>=0);
BOOST_QVM_ASSERT(i<dim);
return m.a[i];
}
static
inline
scalar_type
read_element_idx( int i, my_stuff::vec const & m )
{
BOOST_QVM_ASSERT(i>=0);
BOOST_QVM_ASSERT(i<dim);
return m.a[i];
}
};
template <>
struct
quat_traits<my_stuff::quat>
{
typedef float scalar_type;
template <int I>
static
scalar_type &
write_element( my_stuff::quat & m )
{
BOOST_QVM_STATIC_ASSERT(I>=0);
BOOST_QVM_STATIC_ASSERT(I<4);
return m.a[I];
}
template <int I>
static
scalar_type
read_element( my_stuff::quat const & m )
{
BOOST_QVM_STATIC_ASSERT(I>=0);
BOOST_QVM_STATIC_ASSERT(I<4);
return m.a[I];
}
};
}
}
namespace
my_stuff
{
mat &
operator/=( mat & x, float y )
{
return boost::qvm::operator/=(x,y);
}
vec &
operator/=( vec & x, float y )
{
return boost::qvm::operator/=(x,y);
}
quat &
operator/=( quat & x, float y )
{
return boost::qvm::operator/=(x,y);
}
mat &
operator*=( mat & x, float y )
{
return boost::qvm::operator*=(x,y);
}
vec &
operator*=( vec & x, float y )
{
return boost::qvm::operator*=(x,y);
}
quat &
operator*=( quat & x, float y )
{
return boost::qvm::operator*=(x,y);
}
mat
operator/( mat const & x, float y )
{
return boost::qvm::operator/(x,y);
}
vec
operator/( vec const & x, float y )
{
return boost::qvm::operator/(x,y);
}
quat
operator/( quat const & x, float y )
{
return boost::qvm::operator/(x,y);
}
mat
operator*( mat const & x, float y )
{
return boost::qvm::operator*(x,y);
}
vec
operator*( vec const & x, float y )
{
return boost::qvm::operator*(x,y);
}
quat
operator*( quat const & x, float y )
{
return boost::qvm::operator*(x,y);
}
mat &
operator*=( mat & x, mat const & y )
{
return boost::qvm::operator*=(x,y);
}
mat
operator*=( mat const & x, mat const & y )
{
return boost::qvm::operator*(x,y);
}
vec
operator*( mat const & x, vec const & y )
{
return boost::qvm::operator*(x,y);
}
vec
operator*( quat const & x, vec const & y )
{
return boost::qvm::operator*(x,y);
}
vec
operator*( vec const & x, mat const & y )
{
return boost::qvm::operator*(x,y);
}
bool
operator==( mat const & x, mat const & y )
{
return boost::qvm::operator==(x,y);
}
bool
operator!=( mat const & x, mat const & y )
{
return boost::qvm::operator!=(x,y);
}
bool
operator==( vec const & x, vec const & y )
{
return boost::qvm::operator==(x,y);
}
bool
operator!=( vec const & x, vec const & y )
{
return boost::qvm::operator!=(x,y);
}
bool
operator==( quat const & x, quat const & y )
{
return boost::qvm::operator==(x,y);
}
bool
operator!=( quat const & x, quat const & y )
{
return boost::qvm::operator!=(x,y);
}
}
int
main()
{
using namespace boost::qvm::sfinae;
using namespace my_stuff;
typedef boost::qvm::mat<double,3,3> mat2;
typedef boost::qvm::vec<double,3> vec2;
typedef boost::qvm::quat<double> quat2;
mat ma1, mb1; set_zero(ma1); set_zero(mb1);
vec va1, vb1; set_zero(va1); set_zero(vb1);
quat qa1, qb1; set_zero(qa1); set_zero(qb1);
mat2 ma2, mb2; set_zero(ma2); set_zero(mb2);
vec2 va2, vb2; set_zero(va2); set_zero(vb2);
quat2 qa2, qb2; set_zero(qa2); set_zero(qb2);
set_zero(ma1);
set_zero(mb1);
set_zero(va1);
set_zero(vb1);
set_zero(qa1);
set_zero(qb1);
set_zero(ma2);
set_zero(mb2);
set_zero(va2);
set_zero(vb2);
set_zero(qa2);
set_zero(qb2);
ma1/=2;
va1/=2;
qa1/=2;
ma2/=2;
va2/=2;
qa2/=2;
ma1*=2;
va1*=2;
qa1*=2;
ma2*=2;
va2*=2;
qa2*=2;
mb1=ma1/2;
vb1=va1/2;
qb1=qb1/2;
mb2=convert_to<mat2>(ma1/2);
vb2=convert_to<vec2>(va1/2);
qb2=convert_to<quat2>(qa1/2);
mb1=scalar_cast<float>(ma2/2);
vb1=scalar_cast<float>(va2/2);
qb1=scalar_cast<float>(qa2/2);
mb1=ma1*2;
vb1=va1*2;
qb1=qa1*2;
mb2=convert_to<mat2>(ma1*2);
vb2=convert_to<vec2>(va1*2);
qb2=convert_to<quat2>(qa1*2);
mb1=scalar_cast<float>(ma2*2);
vb1=scalar_cast<float>(va2*2);
qb1=scalar_cast<float>(qa2*2);
ma1*=mb1;
ma1*=scalar_cast<float>(ma2);
ma2*=ma1;
va1=ma1*va1;
va1=qa1*va1;
va1=scalar_cast<float>(ma2*va1);
va1=scalar_cast<float>(ma1*va2);
va1=scalar_cast<float>(ma2*va2);
va1=scalar_cast<float>(qa2*va1);
va1=scalar_cast<float>(qa1*va2);
va1=scalar_cast<float>(qa2*va2);
va2=convert_to<vec2>(ma1*va1);
va2=convert_to<vec2>(qa1*va1);
va2=ma2*va1;
va2=ma1*va2;
va2=ma2*va2;
va2=qa2*va1;
va2=qa1*va2;
va2=qa2*va2;
va1=va1*ma1;
va1=scalar_cast<float>(va1*ma2);
va1=scalar_cast<float>(va2*ma1);
va1=scalar_cast<float>(va2*ma2);
va2=convert_to<vec2>(va1*ma1);
va2=va1*ma2;
va2=va2*ma1;
va2=va2*ma2;
(void) (ma1==mb1);
(void) (ma1==ma2);
(void) (ma2==ma1);
(void) (ma1!=mb1);
(void) (ma1!=ma2);
(void) (ma2!=ma1);
(void) (va1==vb1);
(void) (va1==va2);
(void) (va2==va1);
(void) (va1!=vb1);
(void) (va1!=va2);
(void) (va2!=va1);
(void) (qa1==qb1);
(void) (qa1==qa2);
(void) (qa2==qa1);
(void) (qa1!=qb1);
(void) (qa1!=qa2);
(void) (qa2!=qa1);
return 0;
}

55
libs/qvm/test/inverse_m_test.cpp Normal file
View File

@@ -0,0 +1,55 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat.hpp>
#include <boost/exception/diagnostic_information.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int D>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,D,D> x;
test_qvm::rotation_z(x.a,42.0f);
test_qvm::inverse(x.b,x.a);
test_same_type(x,inverse(x));
{
test_qvm::matrix<M1,D,D> y=inverse(x);
BOOST_QVM_TEST_CLOSE(x.b,y.a,0.000001f);
}
{
test_qvm::matrix<M1,D,D> y=inverse(mref(x));
BOOST_QVM_TEST_CLOSE(x.b,y.a,0.000001f);
}
}
}
int
main()
{
try
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}
catch(
... )
{
std::cerr << "Uncaught exception:\n" << boost::current_exception_diagnostic_information();
return 1;
}
}

41
libs/qvm/test/inverse_q_test.cpp Normal file
View File

@@ -0,0 +1,41 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/quat.hpp>
#include <boost/exception/diagnostic_information.hpp>
#include "test_qvm_quaternion.hpp"
#include "test_qvm.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
void
test()
{
using namespace boost::qvm;
test_qvm::quaternion<Q1> x=rotx_quat(4.2f);
test_same_type(x,inverse(x));
test_qvm::quaternion<Q1> y=rotx_quat(-4.2f);
{
test_qvm::quaternion<Q1> z=inverse(x);
BOOST_QVM_TEST_CLOSE_QUAT(z.a,y.a,0.00001f);
}
{
test_qvm::quaternion<Q1> z=inverse(qref(x));
BOOST_QVM_TEST_CLOSE_QUAT(z.a,y.a,0.00001f);
}
}
}
int
main()
{
test();
return boost::report_errors();
}

31
libs/qvm/test/mag_q_test.cpp Normal file
View File

@@ -0,0 +1,31 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> const x(42,1);
float m1=mag(x);
float m2=mag(qref(x));
float m3=sqrtf(test_qvm::dot<float>(x.a,x.a));
BOOST_QVM_TEST_CLOSE(m1,m3,0.000001f);
BOOST_QVM_TEST_CLOSE(m2,m3,0.000001f);
}
}
int
main()
{
test();
return boost::report_errors();
}

30
libs/qvm/test/mag_sqr_q_test.cpp Normal file
View File

@@ -0,0 +1,30 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> const x(42,1);
float m1=mag_sqr(x);
float m2=mag_sqr(qref(x));
float m3=test_qvm::dot<float>(x.a,x.a);
BOOST_QVM_TEST_CLOSE(m1,m3,0.000001f);
BOOST_QVM_TEST_CLOSE(m2,m3,0.000001f);
}
}
int
main()
{
test();
return boost::report_errors();
}

35
libs/qvm/test/mag_sqr_v_test.cpp Normal file
View File

@@ -0,0 +1,35 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> const x(42,1);
float m1=mag_sqr(x);
float m2=mag_sqr(vref(x));
float m3=test_qvm::dot<float>(x.a,x.a);
BOOST_QVM_TEST_CLOSE(m1,m3,0.000001f);
BOOST_QVM_TEST_CLOSE(m2,m3,0.000001f);
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

35
libs/qvm/test/mag_v_test.cpp Normal file
View File

@@ -0,0 +1,35 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> const x(42,1);
float m1=mag(x);
float m2=mag(vref(x));
float m3=sqrtf(test_qvm::dot<float>(x.a,x.a));
BOOST_QVM_TEST_CLOSE(m1,m3,0.000001f);
BOOST_QVM_TEST_CLOSE(m2,m3,0.000001f);
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

34
libs/qvm/test/mat_index_test.cpp Normal file
View File

@@ -0,0 +1,34 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include "test_qvm_matrix.hpp"
int
main()
{
using namespace boost::qvm;
typedef test_qvm::matrix<M1,2,3> M;
M m;
m.a[0][0]=42.0f;
m.a[0][1]=43.0f;
m.a[0][2]=44.0f;
m.a[1][0]=45.0f;
m.a[1][1]=46.0f;
m.a[1][2]=47.0f;
BOOST_TEST(mat_traits<M>::read_element_idx(0,0,m)==m.a[0][0]);
BOOST_TEST(mat_traits<M>::read_element_idx(0,1,m)==m.a[0][1]);
BOOST_TEST(mat_traits<M>::read_element_idx(0,2,m)==m.a[0][2]);
BOOST_TEST(mat_traits<M>::read_element_idx(1,0,m)==m.a[1][0]);
BOOST_TEST(mat_traits<M>::read_element_idx(1,1,m)==m.a[1][1]);
BOOST_TEST(mat_traits<M>::read_element_idx(1,2,m)==m.a[1][2]);
BOOST_TEST(&mat_traits<M>::write_element_idx(0,0,m)==&m.a[0][0]);
BOOST_TEST(&mat_traits<M>::write_element_idx(0,1,m)==&m.a[0][1]);
BOOST_TEST(&mat_traits<M>::write_element_idx(0,2,m)==&m.a[0][2]);
BOOST_TEST(&mat_traits<M>::write_element_idx(1,0,m)==&m.a[1][0]);
BOOST_TEST(&mat_traits<M>::write_element_idx(1,1,m)==&m.a[1][1]);
BOOST_TEST(&mat_traits<M>::write_element_idx(1,2,m)==&m.a[1][2]);
return boost::report_errors();
}

136
libs/qvm/test/mat_traits_array_test.cpp Normal file
View File

@@ -0,0 +1,136 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_traits_array.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/detail/lightweight_test.hpp>
template <class T,class U>
struct same_type;
template <class T>
struct
same_type<T,T>
{
};
template <class T,class P>
void
test_ref_cast( T & v, P * ptr )
{
using namespace boost::qvm;
BOOST_QVM_STATIC_ASSERT(is_mat<T>::value);
BOOST_QVM_STATIC_ASSERT(mat_traits<T>::rows==3);
BOOST_QVM_STATIC_ASSERT(mat_traits<T>::cols==2);
BOOST_TEST((mat_traits<T>::template read_element<0,0>(v)==ptr[0*2+0]));
BOOST_TEST((mat_traits<T>::template read_element<0,1>(v)==ptr[0*2+1]));
BOOST_TEST((mat_traits<T>::template read_element<1,0>(v)==ptr[1*2+0]));
BOOST_TEST((mat_traits<T>::template read_element<1,1>(v)==ptr[1*2+1]));
BOOST_TEST((mat_traits<T>::template read_element<2,0>(v)==ptr[2*2+0]));
BOOST_TEST((mat_traits<T>::template read_element<2,1>(v)==ptr[2*2+1]));
BOOST_TEST((&mat_traits<T>::template write_element<0,0>(v)==&ptr[0*2+0]));
BOOST_TEST((&mat_traits<T>::template write_element<0,1>(v)==&ptr[0*2+1]));
BOOST_TEST((&mat_traits<T>::template write_element<1,0>(v)==&ptr[1*2+0]));
BOOST_TEST((&mat_traits<T>::template write_element<1,1>(v)==&ptr[1*2+1]));
BOOST_TEST((&mat_traits<T>::template write_element<2,0>(v)==&ptr[2*2+0]));
BOOST_TEST((&mat_traits<T>::template write_element<2,1>(v)==&ptr[2*2+1]));
BOOST_TEST(&v[0][0]==&ptr[0*2+0]);
BOOST_TEST(&v[0][1]==&ptr[0*2+1]);
BOOST_TEST(&v[1][0]==&ptr[1*2+0]);
BOOST_TEST(&v[1][1]==&ptr[1*2+1]);
BOOST_TEST(&v[2][0]==&ptr[2*2+0]);
BOOST_TEST(&v[2][1]==&ptr[2*2+1]);
}
int
main()
{
using namespace boost::qvm;
{
BOOST_QVM_STATIC_ASSERT(!is_mat<int[3]>::value);
BOOST_QVM_STATIC_ASSERT(!is_mat<int[3][3][3]>::value);
BOOST_QVM_STATIC_ASSERT(is_mat<int[3][4]>::value);
BOOST_QVM_STATIC_ASSERT(mat_traits<int[3][4]>::rows==3);
BOOST_QVM_STATIC_ASSERT(mat_traits<int[3][4]>::cols==4);
same_type<mat_traits<int[3][4]>::scalar_type,int>();
same_type< mat<int,3,3>, deduce_mat<int[3][3]>::type >();
same_type< mat<int,3,3>, deduce_mat<int const[3][3]>::type >();
int arr[3][3] = {{00,01,02},{10,11,12},{20,21,22}};
BOOST_TEST((mat_traits<int[3][3]>::read_element<0,0>(arr)==00));
BOOST_TEST((mat_traits<int[3][3]>::read_element<0,1>(arr)==01));
BOOST_TEST((mat_traits<int[3][3]>::read_element<0,2>(arr)==02));
BOOST_TEST((mat_traits<int[3][3]>::read_element<1,0>(arr)==10));
BOOST_TEST((mat_traits<int[3][3]>::read_element<1,1>(arr)==11));
BOOST_TEST((mat_traits<int[3][3]>::read_element<1,2>(arr)==12));
BOOST_TEST((mat_traits<int[3][3]>::read_element<2,0>(arr)==20));
BOOST_TEST((mat_traits<int[3][3]>::read_element<2,1>(arr)==21));
BOOST_TEST((mat_traits<int[3][3]>::read_element<2,2>(arr)==22));
BOOST_TEST((mat_traits<int const[3][3]>::read_element<0,0>(arr)==00));
BOOST_TEST((mat_traits<int const[3][3]>::read_element<0,1>(arr)==01));
BOOST_TEST((mat_traits<int const[3][3]>::read_element<0,2>(arr)==02));
BOOST_TEST((mat_traits<int const[3][3]>::read_element<1,0>(arr)==10));
BOOST_TEST((mat_traits<int const[3][3]>::read_element<1,1>(arr)==11));
BOOST_TEST((mat_traits<int const[3][3]>::read_element<1,2>(arr)==12));
BOOST_TEST((mat_traits<int const[3][3]>::read_element<2,0>(arr)==20));
BOOST_TEST((mat_traits<int const[3][3]>::read_element<2,1>(arr)==21));
BOOST_TEST((mat_traits<int const[3][3]>::read_element<2,2>(arr)==22));
BOOST_TEST((mat_traits<int[3][3]>::read_element_idx(0,0,arr)==00));
BOOST_TEST((mat_traits<int[3][3]>::read_element_idx(0,1,arr)==01));
BOOST_TEST((mat_traits<int[3][3]>::read_element_idx(0,2,arr)==02));
BOOST_TEST((mat_traits<int[3][3]>::read_element_idx(1,0,arr)==10));
BOOST_TEST((mat_traits<int[3][3]>::read_element_idx(1,1,arr)==11));
BOOST_TEST((mat_traits<int[3][3]>::read_element_idx(1,2,arr)==12));
BOOST_TEST((mat_traits<int[3][3]>::read_element_idx(2,0,arr)==20));
BOOST_TEST((mat_traits<int[3][3]>::read_element_idx(2,1,arr)==21));
BOOST_TEST((mat_traits<int[3][3]>::read_element_idx(2,2,arr)==22));
BOOST_TEST((mat_traits<int const[3][3]>::read_element_idx(0,0,arr)==00));
BOOST_TEST((mat_traits<int const[3][3]>::read_element_idx(0,1,arr)==01));
BOOST_TEST((mat_traits<int const[3][3]>::read_element_idx(0,2,arr)==02));
BOOST_TEST((mat_traits<int const[3][3]>::read_element_idx(1,0,arr)==10));
BOOST_TEST((mat_traits<int const[3][3]>::read_element_idx(1,1,arr)==11));
BOOST_TEST((mat_traits<int const[3][3]>::read_element_idx(1,2,arr)==12));
BOOST_TEST((mat_traits<int const[3][3]>::read_element_idx(2,0,arr)==20));
BOOST_TEST((mat_traits<int const[3][3]>::read_element_idx(2,1,arr)==21));
BOOST_TEST((mat_traits<int const[3][3]>::read_element_idx(2,2,arr)==22));
BOOST_TEST((&mat_traits<int[3][3]>::write_element<0,0>(arr)==&arr[0][0]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element<0,1>(arr)==&arr[0][1]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element<0,2>(arr)==&arr[0][2]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element<1,0>(arr)==&arr[1][0]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element<1,1>(arr)==&arr[1][1]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element<1,2>(arr)==&arr[1][2]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element<2,0>(arr)==&arr[2][0]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element<2,1>(arr)==&arr[2][1]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element<2,2>(arr)==&arr[2][2]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element_idx(0,0,arr)==&arr[0][0]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element_idx(0,1,arr)==&arr[0][1]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element_idx(0,2,arr)==&arr[0][2]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element_idx(1,0,arr)==&arr[1][0]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element_idx(1,1,arr)==&arr[1][1]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element_idx(1,2,arr)==&arr[1][2]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element_idx(2,0,arr)==&arr[2][0]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element_idx(2,1,arr)==&arr[2][1]));
BOOST_TEST((&mat_traits<int[3][3]>::write_element_idx(2,2,arr)==&arr[2][2]));
}
{
int arr[42] = {0};
int * ptr=arr+5;
ptr[0*2+0]=42;
ptr[0*2+1]=43;
ptr[1*2+0]=44;
ptr[1*2+1]=45;
ptr[2*2+0]=46;
ptr[2*2+1]=47;
test_ref_cast(ptr_mref<3,2>(ptr),ptr);
int m[3][2] = {{1,1},{1,1},{1,1}};
ptr_mref<3,2>(ptr) += mref(m);
BOOST_TEST(ptr[0*2+0]=43);
BOOST_TEST(ptr[0*2+1]=44);
BOOST_TEST(ptr[1*2+0]=45);
BOOST_TEST(ptr[1*2+1]=46);
BOOST_TEST(ptr[2*2+0]=47);
BOOST_TEST(ptr[2*2+1]=48);
}
return boost::report_errors();
}

49
libs/qvm/test/minus_eq_mm_test.cpp Normal file
View File

@@ -0,0 +1,49 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,Rows,Cols> x(42,2);
{
test_qvm::matrix<M1,Rows,Cols> const y(42,1);
test_qvm::subtract_m(x.b,x.a,y.a);
x-=y;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
{
test_qvm::matrix<M2,Rows,Cols> const y(42,1);
test_qvm::subtract_m(x.b,x.a,y.a);
x-=y;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
}
}
int
main()
{
test<1,2>();
test<2,1>();
test<2,2>();
test<1,3>();
test<3,1>();
test<3,3>();
test<1,4>();
test<4,1>();
test<4,4>();
test<1,5>();
test<5,1>();
test<5,5>();
return boost::report_errors();
}

37
libs/qvm/test/minus_eq_qq_test.cpp Normal file
View File

@@ -0,0 +1,37 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> x(42,2);
{
test_qvm::quaternion<Q1> const y(42,1);
test_qvm::subtract_v(x.b,x.a,y.a);
x-=y;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
{
test_qvm::quaternion<Q2> const y(42,1);
test_qvm::subtract_v(x.b,x.a,y.a);
x-=y;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
}
}
int
main()
{
test();
return boost::report_errors();
}

41
libs/qvm/test/minus_eq_vv_test.cpp Normal file
View File

@@ -0,0 +1,41 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> x(42,2);
{
test_qvm::vector<V1,Dim> const y(42,1);
test_qvm::subtract_v(x.b,x.a,y.a);
x-=y;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
{
test_qvm::vector<V2,Dim> const y(42,1);
test_qvm::subtract_v(x.b,x.a,y.a);
x-=y;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

52
libs/qvm/test/minus_m_test.cpp Normal file
View File

@@ -0,0 +1,52 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int Rows,int Cols>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,Rows,Cols> const x(42,1);
test_qvm::scalar_multiply_m(x.b,x.a,-1.0f);
test_same_type(x,-x);
{
test_qvm::matrix<M1,Rows,Cols> y=-x;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
{
test_qvm::matrix<M1,Rows,Cols> y=-mref(x);
BOOST_QVM_TEST_EQ(x.b,y.a);
}
}
}
int
main()
{
test<1,2>();
test<2,1>();
test<2,2>();
test<1,3>();
test<3,1>();
test<3,3>();
test<1,4>();
test<4,1>();
test<4,4>();
test<1,5>();
test<5,1>();
test<5,5>();
return boost::report_errors();
}

61
libs/qvm/test/minus_mm_test.cpp Normal file
View File

@@ -0,0 +1,61 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int Rows,int Cols>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,Rows,Cols> const x(42,2);
{
test_qvm::matrix<M1,Rows,Cols> const y(42,1);
test_same_type(x,x-y);
test_qvm::matrix<M1,Rows,Cols> r=x-y;
test_qvm::subtract_m(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
{
test_qvm::matrix<M1,Rows,Cols> const y(42,1);
test_qvm::matrix<M2,Rows,Cols> r=mref(x)-y;
test_qvm::subtract_m(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
{
test_qvm::matrix<M1,Rows,Cols> const y(42,1);
test_qvm::matrix<M2,Rows,Cols> r=x-mref(y);
test_qvm::subtract_m(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
}
}
int
main()
{
test<1,2>();
test<2,1>();
test<2,2>();
test<1,3>();
test<3,1>();
test<3,3>();
test<1,4>();
test<4,1>();
test<4,4>();
test<1,5>();
test<5,1>();
test<5,5>();
return boost::report_errors();
}

40
libs/qvm/test/minus_q_test.cpp Normal file
View File

@@ -0,0 +1,40 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/quat.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> const x(42,1);
test_qvm::scalar_multiply_v(x.b,x.a,-1.0f);
test_same_type(x,-x);
{
test_qvm::quaternion<Q1> y=-x;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
{
test_qvm::quaternion<Q1> y=-qref(x);
BOOST_QVM_TEST_EQ(x.b,y.a);
}
}
}
int
main()
{
test();
return boost::report_errors();
}

49
libs/qvm/test/minus_qq_test.cpp Normal file
View File

@@ -0,0 +1,49 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/quat.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> const x(42,2);
{
test_qvm::quaternion<Q1> const y(42,1);
test_same_type(x,x-y);
test_qvm::quaternion<Q1> r=x-y;
test_qvm::subtract_v(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
{
test_qvm::quaternion<Q1> const y(42,1);
test_qvm::quaternion<Q2> r=qref(x)-y;
test_qvm::subtract_v(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
{
test_qvm::quaternion<Q1> const y(42,1);
test_qvm::quaternion<Q2> r=x-qref(y);
test_qvm::subtract_v(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
}
}
int
main()
{
test();
return boost::report_errors();
}

44
libs/qvm/test/minus_v_test.cpp Normal file
View File

@@ -0,0 +1,44 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/vec.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> const x(42,1);
test_qvm::scalar_multiply_v(x.b,x.a,-1.0f);
test_same_type(x,-x);
{
test_qvm::vector<V1,Dim> y=-x;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
{
test_qvm::vector<V1,Dim> y=-vref(x);
BOOST_QVM_TEST_EQ(x.b,y.a);
}
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

53
libs/qvm/test/minus_vv_test.cpp Normal file
View File

@@ -0,0 +1,53 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/vec.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> const x(42,2);
{
test_qvm::vector<V1,Dim> const y(42,1);
test_same_type(x,x-y);
test_qvm::vector<V1,Dim> r=x-y;
test_qvm::subtract_v(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
{
test_qvm::vector<V1,Dim> const y(42,1);
test_qvm::vector<V2,Dim> r=vref(x)-y;
test_qvm::subtract_v(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
{
test_qvm::vector<V1,Dim> const y(42,1);
test_qvm::vector<V2,Dim> r=x-vref(y);
test_qvm::subtract_v(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

42
libs/qvm/test/mul_eq_mm_test.cpp Normal file
View File

@@ -0,0 +1,42 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
{
test_qvm::matrix<M1,Dim,Dim> x(42,1);
test_qvm::matrix<M1,Dim,Dim> const y(42,2);
test_qvm::multiply_m(x.b,x.a,y.a);
x *= y;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
{
test_qvm::matrix<M1,Dim,Dim> x(42,1);
test_qvm::matrix<M2,Dim,Dim> const y(42,2);
test_qvm::multiply_m(x.b,x.a,y.a);
x *= y;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

40
libs/qvm/test/mul_eq_ms_test.cpp Normal file
View File

@@ -0,0 +1,40 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,Rows,Cols> x(42,1);
test_qvm::scalar_multiply_m(x.b,x.a,2.0f);
x*=2;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
}
int
main()
{
test<1,2>();
test<2,1>();
test<2,2>();
test<1,3>();
test<3,1>();
test<3,3>();
test<1,4>();
test<4,1>();
test<4,4>();
test<1,5>();
test<5,1>();
test<5,5>();
return boost::report_errors();
}

46
libs/qvm/test/mul_eq_qq_test.cpp Normal file
View File

@@ -0,0 +1,46 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/mat_operations.hpp>
#include "test_qvm_quaternion.hpp"
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
void
test()
{
using namespace boost::qvm;
for( float a=0; a<6.28f; a+=0.2f )
{
test_qvm::quaternion<Q1> const qx=rotx_quat(a);
test_qvm::quaternion<Q1> const qy=roty_quat(a);
test_qvm::quaternion<Q1> const qz=rotz_quat(a);
test_qvm::quaternion<Q1> q1=identity_quat<float>();
q1 *= qx;
q1 *= qy;
q1 *= qref(qz);
test_qvm::matrix<M1,3,3> const mx=rotx_mat<3>(a);
test_qvm::matrix<M1,3,3> const my=roty_mat<3>(a);
test_qvm::matrix<M1,3,3> const mz=rotz_mat<3>(a);
test_qvm::matrix<M1,3,3> const m=mx*my*mz;
test_qvm::quaternion<Q1> const q2=convert_to< test_qvm::quaternion<Q1> >(m);
BOOST_QVM_TEST_CLOSE_QUAT(q1.a,q2.a,0.00001f);
}
}
}
int
main()
{
test();
return boost::report_errors();
}

28
libs/qvm/test/mul_eq_qs_test.cpp Normal file
View File

@@ -0,0 +1,28 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> x(42,1);
test_qvm::scalar_multiply_v(x.b,x.a,2);
x*=2;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
}
int
main()
{
test();
return boost::report_errors();
}

33
libs/qvm/test/mul_eq_vs_test.cpp Normal file
View File

@@ -0,0 +1,33 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> x(42,1);
test_qvm::scalar_multiply_v(x.b,x.a,2.0f);
x*=2;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
}
int
main()
{
test<1>();
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

55
libs/qvm/test/mul_mm_test.cpp Normal file
View File

@@ -0,0 +1,55 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int R,int CR,int C>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,R,CR> const x(42,1);
test_qvm::matrix<M2,CR,C> const y(42,1);
{
test_qvm::matrix<M3,R,C> r=x*y;
test_qvm::multiply_m(r.b,x.b,y.b);
BOOST_QVM_TEST_CLOSE(r.a,r.b,0.0000001f);
}
{
test_qvm::matrix<M3,R,C> r=mref(x)*y;
test_qvm::multiply_m(r.b,x.b,y.b);
BOOST_QVM_TEST_CLOSE(r.a,r.b,0.0000001f);
}
{
test_qvm::matrix<M3,R,C> r=x*mref(y);
test_qvm::multiply_m(r.b,x.b,y.b);
BOOST_QVM_TEST_CLOSE(r.a,r.b,0.0000001f);
}
}
}
int
main()
{
test<1,2,2>();
test<2,2,1>();
test<2,2,2>();
test<1,3,3>();
test<3,3,1>();
test<3,3,3>();
test<1,4,4>();
test<4,4,1>();
test<4,4,4>();
test<1,5,5>();
test<5,5,1>();
test<5,5,5>();
test<2,3,4>();
return boost::report_errors();
}

52
libs/qvm/test/mul_ms_test.cpp Normal file
View File

@@ -0,0 +1,52 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int Rows,int Cols>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,Rows,Cols> const x(42,1);
test_qvm::scalar_multiply_m(x.b,x.a,2.0f);
test_same_type(x,x*2);
{
test_qvm::matrix<M1,Rows,Cols> y=x*2;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
{
test_qvm::matrix<M1,Rows,Cols> y=mref(x)*2;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
}
}
int
main()
{
test<1,2>();
test<2,1>();
test<2,2>();
test<1,3>();
test<3,1>();
test<3,3>();
test<1,4>();
test<4,1>();
test<4,4>();
test<1,5>();
test<5,1>();
test<5,5>();
return boost::report_errors();
}

75
libs/qvm/test/mul_mv_test.cpp Normal file
View File

@@ -0,0 +1,75 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_mat_operations.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/mat.hpp>
#include <boost/qvm/vec.hpp>
#include "test_qvm_matrix.hpp"
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U>
struct same_type;
template <class T>
struct
same_type<T,T>
{
};
template <class T,class U>
void
check_same_type( T const &, U const & )
{
same_type<T,U>();
}
template <int M,int N>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,M,N> const x(42,1);
test_qvm::vector<V1,N> const y(42,1);
{
test_qvm::vector<V2,M> r=x*y;
test_qvm::multiply_mv(r.b,x.b,y.b);
BOOST_QVM_TEST_CLOSE(r.a,r.b,0.0000001f);
}
{
test_qvm::vector<V2,M> r=mref(x)*y;
test_qvm::multiply_mv(r.b,x.b,y.b);
BOOST_QVM_TEST_CLOSE(r.a,r.b,0.0000001f);
}
{
test_qvm::vector<V2,M> r=x*vref(y);
test_qvm::multiply_mv(r.b,x.b,y.b);
BOOST_QVM_TEST_CLOSE(r.a,r.b,0.0000001f);
}
check_same_type(x*y,boost::qvm::vec<float,M>());
}
}
int
main()
{
test<1,2>();
test<2,1>();
test<2,2>();
test<1,3>();
test<3,1>();
test<3,3>();
test<1,4>();
test<4,1>();
test<4,4>();
test<1,5>();
test<5,1>();
test<5,5>();
return boost::report_errors();
}

45
libs/qvm/test/mul_qq_test.cpp Normal file
View File

@@ -0,0 +1,45 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/quat.hpp>
#include "test_qvm_quaternion.hpp"
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
void
test()
{
using namespace boost::qvm;
for( float a=0; a<6.28f; a+=0.2f )
{
test_qvm::quaternion<Q1> const qx=rotx_quat(a);
test_qvm::quaternion<Q1> const qy=roty_quat(a);
test_qvm::quaternion<Q1> const qz=rotz_quat(a);
test_qvm::quaternion<Q1> const q1=qx*qy*qref(qz);
test_qvm::matrix<M1,3,3> const mx=rotx_mat<3>(a);
test_qvm::matrix<M1,3,3> const my=roty_mat<3>(a);
test_qvm::matrix<M1,3,3> const mz=rotz_mat<3>(a);
test_qvm::matrix<M1,3,3> const m=mx*my*mz;
test_qvm::quaternion<Q1> const q2=convert_to< test_qvm::quaternion<Q1> >(m);
test_same_type(qx,qx*qy);
BOOST_QVM_TEST_CLOSE_QUAT(q1.a,q2.a,0.00001f);
}
}
}
int
main()
{
test();
return boost::report_errors();
}

40
libs/qvm/test/mul_qs_test.cpp Normal file
View File

@@ -0,0 +1,40 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/quat.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> const x(42,1);
test_qvm::scalar_multiply_v(x.b,x.a,2);
test_same_type(x,x*2);
{
test_qvm::quaternion<Q1> y=x*2;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
{
test_qvm::quaternion<Q1> y=qref(x)*2;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
}
}
int
main()
{
test();
return boost::report_errors();
}

51
libs/qvm/test/mul_qv_test.cpp Normal file
View File

@@ -0,0 +1,51 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/operations.hpp>
#include <boost/qvm/vec.hpp>
#include "test_qvm_quaternion.hpp"
#include "test_qvm_matrix.hpp"
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
void
test()
{
using namespace boost::qvm;
for( float a=0; a<6.28f; a+=0.2f )
{
test_qvm::quaternion<Q1> const qx=rotx_quat(a);
test_qvm::quaternion<Q1> const qy=roty_quat(a);
test_qvm::quaternion<Q1> const qz=rotz_quat(a);
test_qvm::matrix<M1,3,3> const mx=rotx_mat<3>(a);
test_qvm::matrix<M1,3,3> const my=roty_mat<3>(a);
test_qvm::matrix<M1,3,3> const mz=rotz_mat<3>(a);
test_qvm::vector<V1,3> const v(42,1);
test_same_type(vec<float,3>(),qx*v);
test_qvm::vector<V1,3> const q_vx=qx*v;
test_qvm::vector<V1,3> const m_vx=mx*v;
test_qvm::vector<V1,3> const q_vy=qy*v;
test_qvm::vector<V1,3> const m_vy=my*v;
test_qvm::vector<V1,3> const q_vz=qz*v;
test_qvm::vector<V1,3> const m_vz=mz*v;
BOOST_QVM_TEST_CLOSE(q_vx.a,m_vx.a,0.001f);
BOOST_QVM_TEST_CLOSE(q_vy.a,m_vy.a,0.001f);
BOOST_QVM_TEST_CLOSE(q_vz.a,m_vz.a,0.001f);
}
}
}
int
main()
{
test();
return boost::report_errors();
}

52
libs/qvm/test/mul_sm_test.cpp Normal file
View File

@@ -0,0 +1,52 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int Rows,int Cols>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,Rows,Cols> const x(42,1);
test_qvm::scalar_multiply_m(x.b,x.a,2.0f);
test_same_type(x,2*x);
{
test_qvm::matrix<M1,Rows,Cols> y=2*x;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
{
test_qvm::matrix<M1,Rows,Cols> y=2*mref(x);
BOOST_QVM_TEST_EQ(x.b,y.a);
}
}
}
int
main()
{
test<1,2>();
test<2,1>();
test<2,2>();
test<1,3>();
test<3,1>();
test<3,3>();
test<1,4>();
test<4,1>();
test<4,4>();
test<1,5>();
test<5,1>();
test<5,5>();
return boost::report_errors();
}

45
libs/qvm/test/mul_sv_test.cpp Normal file
View File

@@ -0,0 +1,45 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/vec.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> const x(42,1);
test_qvm::scalar_multiply_v(x.b,x.a,2.0f);
test_same_type(x,2*x);
{
test_qvm::vector<V1,Dim> y=2*x;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
{
test_qvm::vector<V1,Dim> y=2*vref(x);
BOOST_QVM_TEST_EQ(x.b,y.a);
}
}
}
int
main()
{
test<1>();
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

75
libs/qvm/test/mul_vm_test.cpp Normal file
View File

@@ -0,0 +1,75 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/vec_mat_operations.hpp>
#include <boost/qvm/vec.hpp>
#include "test_qvm_matrix.hpp"
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U>
struct same_type;
template <class T>
struct
same_type<T,T>
{
};
template <class T,class U>
void
check_same_type( T const &, U const & )
{
same_type<T,U>();
}
template <int M,int N>
void
test()
{
using namespace boost::qvm::sfinae;
using namespace boost::qvm;
test_qvm::vector<V1,M> const x(42,1);
test_qvm::matrix<M1,M,N> const y(42,1);
{
test_qvm::vector<V2,N> r=x*y;
test_qvm::multiply_vm(r.b,x.b,y.b);
BOOST_QVM_TEST_CLOSE(r.a,r.b,0.0000001f);
}
{
test_qvm::vector<V2,N> r=vref(x)*y;
test_qvm::multiply_vm(r.b,x.b,y.b);
BOOST_QVM_TEST_CLOSE(r.a,r.b,0.0000001f);
}
{
test_qvm::vector<V2,N> r=x*mref(y);
test_qvm::multiply_vm(r.b,x.b,y.b);
BOOST_QVM_TEST_CLOSE(r.a,r.b,0.0000001f);
}
check_same_type(x*y,boost::qvm::vec<float,N>());
}
}
int
main()
{
test<1,2>();
test<2,1>();
test<2,2>();
test<1,3>();
test<3,1>();
test<3,3>();
test<1,4>();
test<4,1>();
test<4,4>();
test<1,5>();
test<5,1>();
test<5,5>();
return boost::report_errors();
}

45
libs/qvm/test/mul_vs_test.cpp Normal file
View File

@@ -0,0 +1,45 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/vec.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> const x(42,1);
test_qvm::scalar_multiply_v(x.b,x.a,2.0f);
test_same_type(x,x*2);
{
test_qvm::vector<V1,Dim> y=x*2;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
{
test_qvm::vector<V1,Dim> y=vref(x)*2;
BOOST_QVM_TEST_EQ(x.b,y.a);
}
}
}
int
main()
{
test<1>();
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

55
libs/qvm/test/neg_col_test.cpp Normal file
View File

@@ -0,0 +1,55 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/map_mat_mat.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat_traits_array.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm.hpp"
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols,int Col>
void
test()
{
using namespace boost::qvm;
test_qvm::matrix<M1,Rows,Cols> x(42,1);
float r1[Rows][Cols];
for( int i=0; i!=Rows; ++i )
for( int j=0; j!=Cols; ++j )
r1[i][j]=(j==Col?-x.a[i][j]:x.a[i][j]);
float r2[Rows][Cols];
assign(r2,neg_col<Col>(x));
BOOST_QVM_TEST_EQ(r1,r2);
neg_col<Col>(x) + neg_col<Col>(x);
-neg_col<Col>(x);
}
}
int
main()
{
test<2,2,0>();
test<2,2,1>();
test<3,3,0>();
test<3,3,1>();
test<3,3,2>();
test<4,4,0>();
test<4,4,1>();
test<4,4,2>();
test<4,4,3>();
test<5,5,0>();
test<5,5,1>();
test<5,5,2>();
test<5,5,3>();
test<5,5,4>();
return boost::report_errors();
}

55
libs/qvm/test/neg_row_test.cpp Normal file
View File

@@ -0,0 +1,55 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/map_mat_mat.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat_traits_array.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm.hpp"
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols,int Row>
void
test()
{
using namespace boost::qvm;
test_qvm::matrix<M1,Rows,Cols> x(42,1);
float r1[Rows][Cols];
for( int i=0; i!=Rows; ++i )
for( int j=0; j!=Cols; ++j )
r1[i][j]=(i==Row?-x.a[i][j]:x.a[i][j]);
float r2[Rows][Cols];
assign(r2,neg_row<Row>(x));
BOOST_QVM_TEST_EQ(r1,r2);
neg_row<Row>(x) + neg_row<Row>(x);
-neg_row<Row>(x);
}
}
int
main()
{
test<2,2,0>();
test<2,2,1>();
test<3,3,0>();
test<3,3,1>();
test<3,3,2>();
test<4,4,0>();
test<4,4,1>();
test<4,4,2>();
test<4,4,3>();
test<5,5,0>();
test<5,5,1>();
test<5,5,2>();
test<5,5,3>();
test<5,5,4>();
return boost::report_errors();
}

51
libs/qvm/test/normalize_q_test.cpp Normal file
View File

@@ -0,0 +1,51 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/quat.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
void
test()
{
using namespace boost::qvm::sfinae;
{
test_qvm::quaternion<Q1> const x(42,1);
test_same_type(x,normalized(x));
test_qvm::quaternion<Q1> y=normalized(x);
float m=sqrtf(test_qvm::dot<float>(x.a,x.a));
test_qvm::scalar_multiply_v(y.b,x.a,1/m);
BOOST_QVM_TEST_CLOSE(y.a,y.b,0.000001f);
}
{
test_qvm::quaternion<Q1> const x(42,1);
test_qvm::quaternion<Q1> y=normalized(qref(x));
float m=sqrtf(test_qvm::dot<float>(x.a,x.a));
test_qvm::scalar_multiply_v(y.b,x.a,1/m);
BOOST_QVM_TEST_CLOSE(y.a,y.b,0.000001f);
}
{
test_qvm::quaternion<Q1> x(42,1);
float m=sqrtf(test_qvm::dot<float>(x.a,x.a));
test_qvm::scalar_multiply_v(x.b,x.a,1/m);
normalize(x);
BOOST_QVM_TEST_CLOSE(x.a,x.b,0.000001f);
}
}
}
int
main()
{
test();
return boost::report_errors();
}

47
libs/qvm/test/normalize_v_test.cpp Normal file
View File

@@ -0,0 +1,47 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
{
test_qvm::vector<V1,Dim> const x(42,1);
test_same_type(x,normalized(x));
test_qvm::vector<V1,Dim> y=normalized(x);
float m=sqrtf(test_qvm::dot<float>(x.a,x.a));
test_qvm::scalar_multiply_v(y.b,x.a,1/m);
BOOST_QVM_TEST_CLOSE(y.a,y.b,0.000001f);
}
{
test_qvm::vector<V1,Dim> x(42,1);
float m=sqrtf(test_qvm::dot<float>(x.a,x.a));
test_qvm::scalar_multiply_v(x.b,x.a,1/m);
normalize(x);
BOOST_QVM_TEST_CLOSE(x.a,x.b,0.000001f);
}
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

49
libs/qvm/test/plus_eq_mm_test.cpp Normal file
View File

@@ -0,0 +1,49 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,Rows,Cols> x(42,2);
{
test_qvm::matrix<M1,Rows,Cols> const y(42,1);
test_qvm::add_m(x.b,x.a,y.a);
x+=y;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
{
test_qvm::matrix<M2,Rows,Cols> const y(42,1);
test_qvm::add_m(x.b,x.a,y.a);
x+=y;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
}
}
int
main()
{
test<1,2>();
test<2,1>();
test<2,2>();
test<1,3>();
test<3,1>();
test<3,3>();
test<1,4>();
test<4,1>();
test<4,4>();
test<1,5>();
test<5,1>();
test<5,5>();
return boost::report_errors();
}

37
libs/qvm/test/plus_eq_qq_test.cpp Normal file
View File

@@ -0,0 +1,37 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> x(42,2);
{
test_qvm::quaternion<Q1> const y(42,1);
test_qvm::add_v(x.b,x.a,y.a);
x+=y;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
{
test_qvm::quaternion<Q2> const y(42,1);
test_qvm::add_v(x.b,x.a,y.a);
x+=y;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
}
}
int
main()
{
test();
return boost::report_errors();
}

41
libs/qvm/test/plus_eq_vv_test.cpp Normal file
View File

@@ -0,0 +1,41 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> x(42,2);
{
test_qvm::vector<V1,Dim> const y(42,1);
test_qvm::add_v(x.b,x.a,y.a);
x+=y;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
{
test_qvm::vector<V2,Dim> const y(42,1);
test_qvm::add_v(x.b,x.a,y.a);
x+=y;
BOOST_QVM_TEST_EQ(x.a,x.b);
}
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

61
libs/qvm/test/plus_mm_test.cpp Normal file
View File

@@ -0,0 +1,61 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int Rows,int Cols>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::matrix<M1,Rows,Cols> const x(42,2);
{
test_qvm::matrix<M1,Rows,Cols> const y(42,1);
test_same_type(x,x+y);
test_qvm::matrix<M1,Rows,Cols> r=x+y;
test_qvm::add_m(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
{
test_qvm::matrix<M1,Rows,Cols> const y(42,1);
test_qvm::matrix<M2,Rows,Cols> r=mref(x)+y;
test_qvm::add_m(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
{
test_qvm::matrix<M1,Rows,Cols> const y(42,1);
test_qvm::matrix<M2,Rows,Cols> r=x+mref(y);
test_qvm::add_m(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
}
}
int
main()
{
test<1,2>();
test<2,1>();
test<2,2>();
test<1,3>();
test<3,1>();
test<3,3>();
test<1,4>();
test<4,1>();
test<4,4>();
test<1,5>();
test<5,1>();
test<5,5>();
return boost::report_errors();
}

49
libs/qvm/test/plus_qq_test.cpp Normal file
View File

@@ -0,0 +1,49 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/quat.hpp>
#include "test_qvm_quaternion.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::quaternion<Q1> const x(42,2);
{
test_qvm::quaternion<Q1> const y(42,1);
test_same_type(x,x+y);
test_qvm::quaternion<Q1> r=x+y;
test_qvm::add_v(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
{
test_qvm::quaternion<Q1> const y(42,1);
test_qvm::quaternion<Q2> r=qref(x)+y;
test_qvm::add_v(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
{
test_qvm::quaternion<Q1> const y(42,1);
test_qvm::quaternion<Q2> r=x+qref(y);
test_qvm::add_v(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
}
}
int
main()
{
test();
return boost::report_errors();
}

53
libs/qvm/test/plus_vv_test.cpp Normal file
View File

@@ -0,0 +1,53 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/vec.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <class T,class U> struct same_type_tester;
template <class T> struct same_type_tester<T,T> { };
template <class T,class U> void test_same_type( T, U ) { same_type_tester<T,U>(); }
template <int Dim>
void
test()
{
using namespace boost::qvm::sfinae;
test_qvm::vector<V1,Dim> const x(42,2);
{
test_qvm::vector<V1,Dim> const y(42,1);
test_same_type(x,x+y);
test_qvm::vector<V1,Dim> r=x+y;
test_qvm::add_v(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
{
test_qvm::vector<V1,Dim> const y(42,1);
test_qvm::vector<V2,Dim> r=vref(x)+y;
test_qvm::add_v(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
{
test_qvm::vector<V1,Dim> const y(42,1);
test_qvm::vector<V2,Dim> r=x+vref(y);
test_qvm::add_v(r.b,x.b,y.b);
BOOST_QVM_TEST_EQ(r.a,r.b);
}
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

39
libs/qvm/test/projection_test.cpp Normal file
View File

@@ -0,0 +1,39 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <class T>
void
test_perspective_lh( T fov_y, T aspect_ratio, T z_near, T z_far )
{
using namespace boost::qvm;
test_qvm::matrix<M1,4,4> const m=perspective_lh(fov_y,aspect_ratio,z_near,z_far);
test_qvm::matrix_perspective_lh(m.b,fov_y,aspect_ratio,z_near,z_far);
BOOST_QVM_TEST_CLOSE(m.a,m.b,0.000001f);
}
template <class T>
void
test_perspective_rh( T fov_y, T aspect_ratio, T z_near, T z_far )
{
using namespace boost::qvm;
test_qvm::matrix<M1,4,4> const m=perspective_rh(fov_y,aspect_ratio,z_near,z_far);
test_qvm::matrix_perspective_rh(m.b,fov_y,aspect_ratio,z_near,z_far);
BOOST_QVM_TEST_CLOSE(m.a,m.b,0.000001f);
}
}
int
main()
{
test_perspective_lh(0.5f,1.3f,0.1f,2000.0f);
test_perspective_rh(0.5f,1.3f,0.1f,2000.0f);
return boost::report_errors();
}

92
libs/qvm/test/quat_traits_array_test.cpp Normal file
View File

@@ -0,0 +1,92 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_traits_array.hpp>
#include <boost/qvm/quat_operations.hpp>
#include <boost/detail/lightweight_test.hpp>
template <class T,class U>
struct same_type;
template <class T>
struct
same_type<T,T>
{
};
template <class T,class P>
void
test_ref_cast( T & q, P * ptr )
{
using namespace boost::qvm;
BOOST_QVM_STATIC_ASSERT(is_quat<T>::value);
BOOST_TEST(quat_traits<T>::template read_element<0>(q)==ptr[0]);
BOOST_TEST(quat_traits<T>::template read_element<1>(q)==ptr[1]);
BOOST_TEST(quat_traits<T>::template read_element<2>(q)==ptr[2]);
BOOST_TEST(quat_traits<T>::template read_element<3>(q)==ptr[3]);
BOOST_TEST(&quat_traits<T>::template write_element<0>(q)==&ptr[0]);
BOOST_TEST(&quat_traits<T>::template write_element<1>(q)==&ptr[1]);
BOOST_TEST(&quat_traits<T>::template write_element<2>(q)==&ptr[2]);
BOOST_TEST(&quat_traits<T>::template write_element<3>(q)==&ptr[3]);
BOOST_TEST(&q[0]==&ptr[0]);
BOOST_TEST(&q[1]==&ptr[1]);
BOOST_TEST(&q[2]==&ptr[2]);
BOOST_TEST(&q[3]==&ptr[3]);
}
int
main()
{
using namespace boost::qvm;
{
BOOST_QVM_STATIC_ASSERT(is_quat<int[4]>::value);
BOOST_QVM_STATIC_ASSERT(!is_quat<int[4][4]>::value);
BOOST_QVM_STATIC_ASSERT(!is_quat<int[4][4][4]>::value);
same_type<quat_traits<int[4]>::scalar_type,int>();
same_type< quat<int>, deduce_quat<int[4]>::type >();
same_type< quat<int>, deduce_quat<int const[4]>::type >();
int arr[4] = {0,1,2,3};
BOOST_TEST((quat_traits<int[4]>::read_element<0>(arr)==0));
BOOST_TEST((quat_traits<int[4]>::read_element<1>(arr)==1));
BOOST_TEST((quat_traits<int[4]>::read_element<2>(arr)==2));
BOOST_TEST((quat_traits<int[4]>::read_element<3>(arr)==3));
BOOST_TEST((quat_traits<int const[4]>::read_element<0>(arr)==0));
BOOST_TEST((quat_traits<int const[4]>::read_element<1>(arr)==1));
BOOST_TEST((quat_traits<int const[4]>::read_element<2>(arr)==2));
BOOST_TEST((quat_traits<int const[4]>::read_element<3>(arr)==3));
BOOST_TEST((quat_traits<int[4]>::read_element_idx(0,arr)==0));
BOOST_TEST((quat_traits<int[4]>::read_element_idx(1,arr)==1));
BOOST_TEST((quat_traits<int[4]>::read_element_idx(2,arr)==2));
BOOST_TEST((quat_traits<int[4]>::read_element_idx(3,arr)==3));
BOOST_TEST((quat_traits<int const[4]>::read_element_idx(0,arr)==0));
BOOST_TEST((quat_traits<int const[4]>::read_element_idx(1,arr)==1));
BOOST_TEST((quat_traits<int const[4]>::read_element_idx(2,arr)==2));
BOOST_TEST((quat_traits<int const[4]>::read_element_idx(3,arr)==3));
BOOST_TEST((&quat_traits<int[4]>::write_element<0>(arr)==&arr[0]));
BOOST_TEST((&quat_traits<int[4]>::write_element<1>(arr)==&arr[1]));
BOOST_TEST((&quat_traits<int[4]>::write_element<2>(arr)==&arr[2]));
BOOST_TEST((&quat_traits<int[4]>::write_element<3>(arr)==&arr[3]));
BOOST_TEST((&quat_traits<int[4]>::write_element_idx(0,arr)==&arr[0]));
BOOST_TEST((&quat_traits<int[4]>::write_element_idx(1,arr)==&arr[1]));
BOOST_TEST((&quat_traits<int[4]>::write_element_idx(2,arr)==&arr[2]));
BOOST_TEST((&quat_traits<int[4]>::write_element_idx(3,arr)==&arr[3]));
}
{
int arr[42] = {0};
int * ptr=arr+5;
ptr[0]=42;
ptr[1]=43;
ptr[2]=44;
ptr[3]=45;
test_ref_cast(ptr_qref(ptr),ptr);
int q[4] = {1,1,1,1};
ptr_qref(ptr) += qref(q);
BOOST_TEST(ptr[0]==43);
BOOST_TEST(ptr[1]==44);
BOOST_TEST(ptr[2]==45);
BOOST_TEST(ptr[3]==46);
}
return boost::report_errors();
}

96
libs/qvm/test/rot_mat_test.cpp Normal file
View File

@@ -0,0 +1,96 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include "test_qvm_matrix.hpp"
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <int D>
void
test_x()
{
using namespace boost::qvm;
test_qvm::vector<V1,3> axis; axis.a[0]=1;
for( float r=0; r<6.28f; r+=0.5f )
{
test_qvm::matrix<M1,D,D> const m1=rot_mat<D>(axis,r);
test_qvm::rotation_x(m1.b,r);
BOOST_QVM_TEST_EQ(m1.a,m1.b);
test_qvm::matrix<M1,D,D> m2(42,1);
set_rot(m2,axis,r);
test_qvm::rotation_x(m2.b,r);
BOOST_QVM_TEST_EQ(m2.a,m2.b);
test_qvm::matrix<M1,D,D> m3(42,1);
test_qvm::matrix<M1,D,D> m4(42,1);
rotate(m3,axis,r);
m3 = m3*m1;
BOOST_QVM_TEST_EQ(m3.a,m3.a);
}
}
template <int D>
void
test_y()
{
using namespace boost::qvm;
test_qvm::vector<V1,3> axis; axis.a[1]=1;
for( float r=0; r<6.28f; r+=0.5f )
{
test_qvm::matrix<M1,D,D> m1=rot_mat<D>(axis,r);
test_qvm::rotation_y(m1.b,r);
BOOST_QVM_TEST_EQ(m1.a,m1.b);
test_qvm::matrix<M1,D,D> m2(42,1);
set_rot(m2,axis,r);
test_qvm::rotation_y(m2.b,r);
BOOST_QVM_TEST_EQ(m2.a,m2.b);
test_qvm::matrix<M1,D,D> m3(42,1);
test_qvm::matrix<M1,D,D> m4(42,1);
rotate(m3,axis,r);
m3 = m3*m1;
BOOST_QVM_TEST_EQ(m3.a,m3.a);
}
}
template <int D>
void
test_z()
{
using namespace boost::qvm;
test_qvm::vector<V1,3> axis; axis.a[2]=1;
for( float r=0; r<6.28f; r+=0.5f )
{
test_qvm::matrix<M1,D,D> m1=rot_mat<D>(axis,r);
test_qvm::rotation_z(m1.b,r);
BOOST_QVM_TEST_EQ(m1.a,m1.b);
test_qvm::matrix<M1,D,D> m2(42,1);
set_rot(m2,axis,r);
test_qvm::rotation_z(m2.b,r);
BOOST_QVM_TEST_EQ(m2.a,m2.b);
test_qvm::matrix<M1,D,D> m3(42,1);
test_qvm::matrix<M1,D,D> m4(42,1);
rotate(m3,axis,r);
m3 = m3*m1;
BOOST_QVM_TEST_EQ(m3.a,m3.a);
}
}
}
int
main()
{
test_x<3>();
test_y<3>();
test_z<3>();
test_x<4>();
test_y<4>();
test_z<4>();
test_x<5>();
test_y<5>();
test_z<5>();
return boost::report_errors();
}

95
libs/qvm/test/rot_quat_test.cpp Normal file
View File

@@ -0,0 +1,95 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/mat_operations.hpp>
#include "test_qvm_matrix.hpp"
#include "test_qvm_quaternion.hpp"
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
void
test_x()
{
using namespace boost::qvm;
test_qvm::vector<V1,3> axis; axis.a[0]=1;
for( float r=0; r<6.28f; r+=0.5f )
{
test_qvm::quaternion<Q1> q1=rot_quat(axis,r);
test_qvm::matrix<M1,3,3> x1=convert_to< test_qvm::matrix<M1,3,3> >(q1);
test_qvm::rotation_x(x1.b,r);
BOOST_QVM_TEST_CLOSE(x1.a,x1.b,0.000001f);
test_qvm::quaternion<Q2> q2(42,1);
set_rot(q2,axis,r);
test_qvm::matrix<M2,3,3> x2=convert_to< test_qvm::matrix<M2,3,3> >(q2);
test_qvm::rotation_x(x2.b,r);
BOOST_QVM_TEST_CLOSE(x2.a,x2.b,0.000001f);
test_qvm::quaternion<Q1> q3(42,1);
test_qvm::quaternion<Q1> q4(42,1);
rotate(q3,axis,r);
q3 = q3*q1;
BOOST_QVM_TEST_EQ(q3.a,q3.a);
}
}
void
test_y()
{
using namespace boost::qvm;
test_qvm::vector<V1,3> axis; axis.a[1]=1;
for( float r=0; r<6.28f; r+=0.5f )
{
test_qvm::quaternion<Q1> q1=rot_quat(axis,r);
test_qvm::matrix<M1,3,3> x1=convert_to< test_qvm::matrix<M1,3,3> >(q1);
test_qvm::rotation_y(x1.b,r);
BOOST_QVM_TEST_CLOSE(x1.a,x1.b,0.000001f);
test_qvm::quaternion<Q2> q2(42,1);
set_rot(q2,axis,r);
test_qvm::matrix<M2,3,3> x2=convert_to< test_qvm::matrix<M2,3,3> >(q2);
test_qvm::rotation_y(x2.b,r);
BOOST_QVM_TEST_CLOSE(x2.a,x2.b,0.000001f);
test_qvm::quaternion<Q1> q3(42,1);
test_qvm::quaternion<Q1> q4(42,1);
rotate(q3,axis,r);
q3 = q3*q1;
BOOST_QVM_TEST_EQ(q3.a,q3.a);
}
}
void
test_z()
{
using namespace boost::qvm;
test_qvm::vector<V1,3> axis; axis.a[2]=1;
for( float r=0; r<6.28f; r+=0.5f )
{
test_qvm::quaternion<Q1> q1=rot_quat(axis,r);
test_qvm::matrix<M1,3,3> x1=convert_to< test_qvm::matrix<M1,3,3> >(q1);
test_qvm::rotation_z(x1.b,r);
BOOST_QVM_TEST_CLOSE(x1.a,x1.b,0.000001f);
test_qvm::quaternion<Q2> q2(42,1);
set_rot(q2,axis,r);
test_qvm::matrix<M2,3,3> x2=convert_to< test_qvm::matrix<M2,3,3> >(q2);
test_qvm::rotation_z(x2.b,r);
BOOST_QVM_TEST_CLOSE(x2.a,x2.b,0.000001f);
test_qvm::quaternion<Q1> q3(42,1);
test_qvm::quaternion<Q1> q4(42,1);
rotate(q3,axis,r);
q3 = q3*q1;
BOOST_QVM_TEST_EQ(q3.a,q3.a);
}
}
}
int
main()
{
test_x();
test_y();
test_z();
return boost::report_errors();
}

44
libs/qvm/test/rotx_mat_test.cpp Normal file
View File

@@ -0,0 +1,44 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm;
for( float r=0; r<6.28f; r+=0.5f )
{
test_qvm::matrix<M1,Dim,Dim> const m1=rotx_mat<Dim>(r);
test_qvm::rotation_x(m1.b,r);
BOOST_QVM_TEST_CLOSE(m1.a,m1.b,0.000001f);
test_qvm::matrix<M1,Dim,Dim> m2(42,1);
set_rotx(m2,r);
test_qvm::rotation_x(m2.b,r);
BOOST_QVM_TEST_CLOSE(m2.a,m2.b,0.000001f);
test_qvm::matrix<M1,Dim,Dim> m3(42,1);
test_qvm::matrix<M1,Dim,Dim> r1=m3*m1;
rotate_x(m3,r);
BOOST_QVM_TEST_EQ(m3.a,r1.a);
}
rotx_mat<Dim>(0.0f)+rotx_mat<Dim>(0.0f);
-rotx_mat<Dim>(0.0f);
}
}
int
main()
{
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

45
libs/qvm/test/rotx_quat_test.cpp Normal file
View File

@@ -0,0 +1,45 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/quat.hpp>
#include "test_qvm_quaternion.hpp"
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
void
test()
{
using namespace boost::qvm;
for( float r=0; r<6.28f; r+=0.5f )
{
test_qvm::quaternion<Q1> q1=rotx_quat(r);
test_qvm::matrix<M1,3,3> m1=convert_to< test_qvm::matrix<M1,3,3> >(q1);
test_qvm::rotation_x(m1.b,r);
BOOST_QVM_TEST_CLOSE(m1.a,m1.b,0.000001f);
test_qvm::quaternion<Q2> q2(42,1);
set_rotx(q2,r);
test_qvm::matrix<M1,3,3> m2=convert_to< test_qvm::matrix<M1,3,3> >(q2);
test_qvm::rotation_x(m2.b,r);
BOOST_QVM_TEST_CLOSE(m2.a,m2.b,0.000001f);
test_qvm::quaternion<Q1> q3(42,1);
test_qvm::quaternion<Q1> r1=q3*q1;
rotate_x(q3,r);
BOOST_QVM_TEST_EQ(q3.a,r1.a);
}
rotx_quat(0.0f)+rotx_quat(0.0f);
-rotx_quat(0.0f);
}
}
int
main()
{
test();
return boost::report_errors();
}

44
libs/qvm/test/roty_mat_test.cpp Normal file
View File

@@ -0,0 +1,44 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm;
for( float r=0; r<6.28f; r+=0.5f )
{
test_qvm::matrix<M1,Dim,Dim> const m1=roty_mat<Dim>(r);
test_qvm::rotation_y(m1.b,r);
BOOST_QVM_TEST_CLOSE(m1.a,m1.b,0.000001f);
test_qvm::matrix<M1,Dim,Dim> m2(42,1);
set_roty(m2,r);
test_qvm::rotation_y(m2.b,r);
BOOST_QVM_TEST_CLOSE(m2.a,m2.b,0.000001f);
test_qvm::matrix<M1,Dim,Dim> m3(42,1);
test_qvm::matrix<M1,Dim,Dim> r1=m3*m1;
rotate_y(m3,r);
BOOST_QVM_TEST_EQ(m3.a,r1.a);
}
roty_mat<Dim>(0.0f)+roty_mat<Dim>(0.0f);
-roty_mat<Dim>(0.0f);
}
}
int
main()
{
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

45
libs/qvm/test/roty_quat_test.cpp Normal file
View File

@@ -0,0 +1,45 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/quat.hpp>
#include "test_qvm_quaternion.hpp"
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
void
test()
{
using namespace boost::qvm;
for( float r=0; r<6.28f; r+=0.5f )
{
test_qvm::quaternion<Q1> q1=roty_quat(r);
test_qvm::matrix<M1,3,3> m1=convert_to< test_qvm::matrix<M1,3,3> >(q1);
test_qvm::rotation_y(m1.b,r);
BOOST_QVM_TEST_CLOSE(m1.a,m1.b,0.000001f);
test_qvm::quaternion<Q2> q2(42,1);
set_roty(q2,r);
test_qvm::matrix<M1,3,3> m2=convert_to< test_qvm::matrix<M1,3,3> >(q2);
test_qvm::rotation_y(m2.b,r);
BOOST_QVM_TEST_CLOSE(m2.a,m2.b,0.000001f);
test_qvm::quaternion<Q1> q3(42,1);
test_qvm::quaternion<Q1> r1=q3*q1;
rotate_y(q3,r);
BOOST_QVM_TEST_EQ(q3.a,r1.a);
}
roty_quat(0.0f)+roty_quat(0.0f);
-roty_quat(0.0f);
}
}
int
main()
{
test();
return boost::report_errors();
}

45
libs/qvm/test/rotz_mat_test.cpp Normal file
View File

@@ -0,0 +1,45 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm;
for( float r=0; r<6.28f; r+=0.5f )
{
test_qvm::matrix<M1,Dim,Dim> const m1=rotz_mat<Dim>(r);
test_qvm::rotation_z(m1.b,r);
BOOST_QVM_TEST_CLOSE(m1.a,m1.b,0.000001f);
test_qvm::matrix<M1,Dim,Dim> m2(42,1);
set_rotz(m2,r);
test_qvm::rotation_z(m2.b,r);
BOOST_QVM_TEST_CLOSE(m2.a,m2.b,0.000001f);
test_qvm::matrix<M1,Dim,Dim> m3(42,1);
test_qvm::matrix<M1,Dim,Dim> r1=m3*m1;
rotate_z(m3,r);
BOOST_QVM_TEST_EQ(m3.a,r1.a);
}
rotz_mat<Dim>(0.0f)+rotz_mat<Dim>(0.0f);
-rotz_mat<Dim>(0.0f);
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

45
libs/qvm/test/rotz_quat_test.cpp Normal file
View File

@@ -0,0 +1,45 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/quat_operations.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/quat.hpp>
#include "test_qvm_quaternion.hpp"
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
void
test()
{
using namespace boost::qvm;
for( float r=0; r<6.28f; r+=0.5f )
{
test_qvm::quaternion<Q1> q1=rotz_quat(r);
test_qvm::matrix<M1,3,3> m1=convert_to< test_qvm::matrix<M1,3,3> >(q1);
test_qvm::rotation_z(m1.b,r);
BOOST_QVM_TEST_CLOSE(m1.a,m1.b,0.000001f);
test_qvm::quaternion<Q2> q2(42,1);
set_rotz(q2,r);
test_qvm::matrix<M1,3,3> m2=convert_to< test_qvm::matrix<M1,3,3> >(q2);
test_qvm::rotation_z(m2.b,r);
BOOST_QVM_TEST_CLOSE(m2.a,m2.b,0.000001f);
test_qvm::quaternion<Q1> q3(42,1);
test_qvm::quaternion<Q1> r1=q3*q1;
rotate_z(q3,r);
BOOST_QVM_TEST_EQ(q3.a,r1.a);
}
rotz_quat(0.0f)+rotz_quat(0.0f);
-rotz_quat(0.0f);
}
}
int
main()
{
test();
return boost::report_errors();
}

40
libs/qvm/test/row_mat_test.cpp Normal file
View File

@@ -0,0 +1,40 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/map.hpp>
#include <boost/qvm/mat_traits_array.hpp>
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/mat.hpp>
#include "test_qvm_vector.hpp"
#include "gold.hpp"
namespace
{
template <int Dim>
void
test()
{
using namespace boost::qvm;
test_qvm::vector<V1,Dim> x(42,1);
float y[1][Dim]; assign(y,row_mat(x));
BOOST_QVM_TEST_EQ(x.a,y[0]);
test_qvm::scalar_multiply_v(x.b,x.a,2.0f);
row<0>(row_mat(x)) *= 2;
BOOST_QVM_TEST_EQ(x.a,x.b);
row_mat(x) + row_mat(x);
-row_mat(x);
}
}
int
main()
{
test<2>();
test<3>();
test<4>();
test<5>();
return boost::report_errors();
}

118
libs/qvm/test/row_test.cpp Normal file
View File

@@ -0,0 +1,118 @@
//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
//Distributed under the Boost Software License, Version 1.0. (See accompanying
//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/qvm/map_mat_vec.hpp>
#include <boost/qvm/vec_traits_array.hpp>
#include <boost/qvm/mat_operations.hpp>
#include <boost/qvm/vec_operations.hpp>
#include <boost/qvm/vec.hpp>
#include "test_qvm.hpp"
#include "test_qvm_matrix.hpp"
#include "gold.hpp"
namespace
{
template <int Rows,int Cols,int Row>
void
test()
{
using namespace boost::qvm;
test_qvm::matrix<M1,Rows,Cols> x(42,1);
float r1[Cols];
for( int i=0; i!=Cols; ++i )
r1[i]=x.a[Row][i];
float r2[Cols];
assign(r2,row<Row>(x));
BOOST_QVM_TEST_EQ(r1,r2);
row<Row>(x) *= 2;
for( int i=0; i!=Cols; ++i )
r1[i]=x.a[Row][i];
assign(r2,row<Row>(x));
BOOST_QVM_TEST_EQ(r1,r2);
row<Row>(x) + row<Row>(x);
-row<Row>(x);
}
}
int
main()
{
test<2,1,0>();
test<2,1,1>();
test<3,1,0>();
test<3,1,1>();
test<3,1,2>();
test<4,1,0>();
test<4,1,1>();
test<4,1,2>();
test<4,1,3>();
test<5,1,0>();
test<5,1,1>();
test<5,1,2>();
test<5,1,3>();
test<5,1,4>();
test<2,2,0>();
test<2,2,1>();
test<3,2,0>();
test<3,2,1>();
test<3,2,2>();
test<4,2,0>();
test<4,2,1>();
test<4,2,2>();
test<4,2,3>();
test<5,2,0>();
test<5,2,1>();
test<5,2,2>();
test<5,2,3>();
test<5,2,4>();
test<2,3,0>();
test<2,3,1>();
test<3,3,0>();
test<3,3,1>();
test<3,3,2>();
test<4,3,0>();
test<4,3,1>();
test<4,3,2>();
test<4,3,3>();
test<5,3,0>();
test<5,3,1>();
test<5,3,2>();
test<5,3,3>();
test<5,3,4>();
test<2,4,0>();
test<2,4,1>();
test<3,4,0>();
test<3,4,1>();
test<3,4,2>();
test<4,4,0>();
test<4,4,1>();
test<4,4,2>();
test<4,4,3>();
test<5,4,0>();
test<5,4,1>();
test<5,4,2>();
test<5,4,3>();
test<5,4,4>();
test<2,5,0>();
test<2,5,1>();
test<3,5,0>();
test<3,5,1>();
test<3,5,2>();
test<4,5,0>();
test<4,5,1>();
test<4,5,2>();
test<4,5,3>();
test<5,5,0>();
test<5,5,1>();
test<5,5,2>();
test<5,5,3>();
test<5,5,4>();
return boost::report_errors();
}

Some files were not shown because too many files have changed in this diff Show More