mirror of
https://github.com/saitohirga/WSJT-X.git
synced 2025-10-31 04:50:34 -04:00
310 lines
6.6 KiB
C++
310 lines
6.6 KiB
C++
#undef BOOST_UBLAS_NO_EXCEPTIONS
|
|
#include "common/testhelper.hpp"
|
|
#include <boost/numeric/ublas/vector.hpp>
|
|
#include <boost/numeric/ublas/matrix.hpp>
|
|
#include <boost/numeric/ublas/assignment.hpp>
|
|
#include <boost/numeric/ublas/io.hpp>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <complex>
|
|
#include <iomanip>
|
|
#include "utils.hpp"
|
|
|
|
#ifdef BOOST_UBLAS_CPP_GE_2011
|
|
|
|
using namespace boost::numeric::ublas;
|
|
|
|
using std::cout;
|
|
using std::endl;
|
|
|
|
template < class T >
|
|
bool test_vector( std::string type_name)
|
|
{
|
|
std::stringstream stream;
|
|
stream << "Testing for: " << type_name;
|
|
BOOST_UBLAS_DEBUG_TRACE( stream.str() );
|
|
|
|
bool pass = true;
|
|
|
|
{
|
|
typedef fixed_vector<T, 1> vec1;
|
|
|
|
vec1 v1( 122.0 );
|
|
|
|
pass &= ( v1(0) == (T)122 );
|
|
|
|
}
|
|
|
|
{
|
|
typedef fixed_vector<T, 3> vec3;
|
|
|
|
vec3 v1((T)0.0, (T)0.0, (T)0.0);
|
|
|
|
pass &=(sizeof( vec3 ) == v1.size()*sizeof( T ) ) ;
|
|
|
|
vector<T> v( 3, 0 ) ;
|
|
|
|
pass &= compare( v1, v );
|
|
|
|
v1 <<= 10.0, 10, 33;
|
|
v <<= 10.0, 10, 33;
|
|
|
|
//cout << std::setprecision(20) << v1 << '\n' << v;
|
|
|
|
pass &= compare( v1, v );
|
|
|
|
|
|
vec3 v2;
|
|
|
|
v2( 0 ) = 10.0; v2( 1 ) = 10; v2( 2 ) = 33;
|
|
pass &= compare( v, v2 );
|
|
|
|
v2 += v;
|
|
|
|
pass &= compare( v2, 2*v );
|
|
|
|
|
|
v1 = 2*v1 + v - 6*v2;
|
|
pass &= compare( v1, (3-2*6)*v );
|
|
|
|
|
|
vec3 v3{ (T)-90.0, (T)-90.0, (T)-297.0 };
|
|
pass &= compare( v3, v1 );
|
|
|
|
vec3 v4 = { (T)-90.0, (T)-90.0, (T)-297.0 };
|
|
pass &= compare( v4, v1 );
|
|
|
|
vec3 v5( (T)-90.0, (T)-90.0, (T)-297.0 );
|
|
pass &= compare( v5, v1 );
|
|
|
|
vec3 v6((T) 5.0, (T)8.0, (T)9.0);
|
|
|
|
matrix<T> M = outer_prod( v6, v6), L( 3, 3);
|
|
|
|
L <<= 25, 40, 45, 40, 64, 72, 45, 72, 81;
|
|
|
|
pass &= compare( M, L );
|
|
|
|
L <<= 1, 2, 3, 4, 5, 6, 7, 8, 9;
|
|
v6 <<= 4, 5, 6;
|
|
vec3 v7 ( (T)32.0, (T)77.0, (T)122.0 );
|
|
|
|
pass &= compare( v7, prod(L, v6) );
|
|
|
|
vec3 v8;
|
|
noalias( v8 ) = prod(L, v6);
|
|
|
|
pass &= compare( v7, v8 );
|
|
|
|
}
|
|
|
|
|
|
{
|
|
const std::size_t N = 33;
|
|
typedef fixed_vector<T, N> vec33;
|
|
|
|
vec33 v1;
|
|
vector<T> v( N );
|
|
|
|
for ( std::size_t i = 0; i!= v1.size(); i++)
|
|
{
|
|
v1( i ) = 3.14159*i;
|
|
v ( i ) = 3.14159*i;
|
|
}
|
|
|
|
pass &= compare( v1, v );
|
|
|
|
|
|
auto ip = inner_prod( v, v);
|
|
auto ip1 = inner_prod( v1, v1);
|
|
|
|
pass &= ( ip == ip1 ) ;
|
|
|
|
T c = 0;
|
|
for (auto i = v1.begin(); i != v1.end(); i++)
|
|
{
|
|
*i = c;
|
|
c = c + 1;
|
|
}
|
|
|
|
c = 0;
|
|
for (auto i = v.begin(); i != v.end(); i++)
|
|
{
|
|
*i = c;
|
|
c = c + 1;
|
|
}
|
|
|
|
pass &= compare( v1, v );
|
|
|
|
// Check if bad index indeed works
|
|
try {
|
|
T a;
|
|
a=v1( 100 );
|
|
BOOST_UBLAS_NOT_USED( a );
|
|
|
|
} catch ( bad_index &e) {
|
|
std::cout << " Caught (GOOD): " << e.what() << endl;
|
|
pass &= true;
|
|
}
|
|
|
|
|
|
}
|
|
return pass;
|
|
}
|
|
|
|
template < class T >
|
|
bool test_matrix( std::string type_name)
|
|
{
|
|
std::stringstream stream;
|
|
stream << "Testing for: " << type_name;
|
|
BOOST_UBLAS_DEBUG_TRACE( stream.str() );
|
|
|
|
bool pass = true;
|
|
|
|
typedef fixed_matrix<T, 3, 4> mat34;
|
|
typedef fixed_matrix<T, 4, 3> mat43;
|
|
typedef fixed_matrix<T, 3, 3> mat33;
|
|
|
|
|
|
{
|
|
typedef fixed_matrix<T, 1, 1> mat1;
|
|
|
|
mat1 m1( 122.0 );
|
|
|
|
pass &= ( m1(0, 0) == (T)122 );
|
|
}
|
|
|
|
|
|
{
|
|
mat34 m1( 3.0 );
|
|
|
|
pass &=(sizeof( mat34 ) == m1.size1()*m1.size2()*sizeof( T ) ) ;
|
|
|
|
matrix<T> m( 3.0, 4.0, 3.0 ) ;
|
|
|
|
pass &= compare( m1, m );
|
|
|
|
cout << m1 << endl;
|
|
cout << m << endl;
|
|
|
|
|
|
m1 <<= 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12;
|
|
m <<= 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12;
|
|
|
|
pass &= compare( m1, m );
|
|
|
|
cout << m1 << endl;
|
|
cout << m << endl;
|
|
|
|
mat34 m2( 0.0 );
|
|
|
|
T count = 1 ;
|
|
for ( std::size_t i = 0; i != m2.size1(); i++)
|
|
{
|
|
for (std::size_t j = 0; j!= m2.size2(); j++)
|
|
{
|
|
m2( i, j ) = count;
|
|
count = count + 1;
|
|
}
|
|
|
|
}
|
|
pass &= compare( m2, m );
|
|
cout << m2 << endl;
|
|
|
|
}
|
|
{
|
|
mat34 m1 = { (T)1, (T)2, (T)3, (T)3, (T)3, (T)2, (T)5, (T)4, (T)2, (T)6, (T)5, (T)2 };
|
|
mat43 m2 = { (T)4, (T)5, (T)6, (T)3, (T)2, (T)2, (T)1, (T)4, (T)2, (T)6, (T)5, (T)2 };
|
|
|
|
mat33 m3 = prod(m1, m2);
|
|
|
|
matrix<T> m(3, 3);
|
|
m <<= 31,36,22,47,59,40,43,52,38;
|
|
|
|
pass &= compare(m ,m3);
|
|
|
|
mat33 m4;
|
|
m4 <<= (T)1, (T)2, (T)1, (T)2, (T)1, (T)3, (T)1, (T)2, (T) 5;
|
|
m3 = prod(m4, trans(m4));
|
|
|
|
m<<=6,7,10,7,14,19,10,19,30;
|
|
|
|
cout << m3 << endl;
|
|
pass &= compare(m ,m3);
|
|
|
|
m3 = 2 * m4 - 1 * m3;
|
|
|
|
cout << m3;
|
|
|
|
m <<= -4,-3,-8,-3,-12,-13,-8,-15,-20;
|
|
|
|
pass &= compare(m, m3);
|
|
|
|
m = m3;
|
|
|
|
m3 = trans(m);
|
|
|
|
pass &= compare(m3, trans(m));
|
|
|
|
// Check if bad index indeed works
|
|
try {
|
|
T a;
|
|
a=m1( 100, 100 );
|
|
BOOST_UBLAS_NOT_USED( a );
|
|
|
|
} catch ( bad_index &e) {
|
|
std::cout << " Caught (GOOD): " << e.what() << endl;
|
|
pass &= true;
|
|
}
|
|
|
|
}
|
|
|
|
return pass;
|
|
|
|
}
|
|
|
|
BOOST_UBLAS_TEST_DEF (test_fixed) {
|
|
|
|
BOOST_UBLAS_DEBUG_TRACE( "Starting fixed container tests" );
|
|
|
|
BOOST_UBLAS_TEST_CHECK( test_vector< double >( "double") );
|
|
BOOST_UBLAS_TEST_CHECK( test_vector< float >( "float") );
|
|
BOOST_UBLAS_TEST_CHECK( test_vector< int >( "int") );
|
|
|
|
BOOST_UBLAS_TEST_CHECK( test_vector< std::complex<double> >( "std::complex<double>") );
|
|
BOOST_UBLAS_TEST_CHECK( test_vector< std::complex<float> >( "std::complex<float>") );
|
|
BOOST_UBLAS_TEST_CHECK( test_vector< std::complex<int> >( "std::complex<int>") );
|
|
|
|
BOOST_UBLAS_TEST_CHECK( test_matrix< double >( "double") );
|
|
BOOST_UBLAS_TEST_CHECK( test_matrix< float >( "float") );
|
|
BOOST_UBLAS_TEST_CHECK( test_matrix< int >( "int") );
|
|
|
|
BOOST_UBLAS_TEST_CHECK( test_matrix< std::complex<double> >( "std::complex<double>") );
|
|
BOOST_UBLAS_TEST_CHECK( test_matrix< std::complex<float> >( "std::complex<float>") );
|
|
BOOST_UBLAS_TEST_CHECK( test_matrix< std::complex<int> >( "std::complex<int>") );
|
|
}
|
|
|
|
|
|
int main () {
|
|
|
|
BOOST_UBLAS_TEST_BEGIN();
|
|
|
|
BOOST_UBLAS_TEST_DO( test_fixed );
|
|
|
|
BOOST_UBLAS_TEST_END();
|
|
return EXIT_SUCCESS;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
int main () {
|
|
|
|
BOOST_UBLAS_TEST_BEGIN();
|
|
BOOST_UBLAS_TEST_END();
|
|
|
|
return EXIT_SUCCESS;
|
|
|
|
}
|
|
#endif // BOOST_UBLAS_CPP_GE_2011
|