---

test.cc

Go to the documentation of this file.

#include <iostream.h>
#include<gslwrap/matrix_float.h>
#include<gslwrap/matrix_double.h>
#include<gslwrap/vector_float.h>
#include<gslwrap/vector_int.h>
#include<gslwrap/vector_double.h>
#include<gslwrap/random_generator.h>
using namespace gsl;

void
test_vector()
{
        gsl::vector vd(10);
        gsl::vector_float  vf(10);
        gsl::vector_int    vi(10);
}

// Testing  creation, dimensioning and assigning functions:
void 
vector_float_test()
{
        vector_float test;
        vector_float mal(10);
        for (int i=0; i<10; i++)
        {mal[i] = i;}

        test = mal;
        cout << "Test vector should be:" << endl <<mal<< endl;
        cout << "Test vector is:" << endl <<test<< endl;
        
        if (mal != test)
                cout << "vector_float ERROR Test did not pass !! --------------" << endl;
        else 
                cout << "vector_float Test passed !! --------------" << endl;
}

void
VectorViewTest()
{
        cout << "VectorViewTest --------------------------" << endl;
        int i,j;
        int size=5;
        matrix_float m(size, size);
        matrix_float ver(size, size);ver.set_all(5.0);
        vector_float v(size);
        for (i=0;i<size;i++)
        {
                v[i]=size-(i+1);
                for (j=0;j<size;j++)
                        m(i,j)=(i+1);
        }
        cout << "m=" << endl << m << endl;
        cout << "v=" << endl << v << endl;

        vector_float_view col_viewer = m.column(3);
        vector_float_view viewer = m.row(3);
        cout << "viewer (3.row before adding)=" << endl << viewer << endl;
        cout << "col_viewer (3.col before adding)=" << endl << col_viewer << endl;
        for (i=0;i<m.get_cols();i++)
                m.column(i) += v;

        cout << "viewer (3.row after adding) =" << endl << viewer << endl;
        cout << "col_viewer (3.col after adding)=" << endl << col_viewer << endl;
        cout << "\"m+v\"" << endl << m << endl;
        
        col_viewer.change_view(viewer);
        cout << "col_viewer after changing to viewer=" << endl << col_viewer << endl;

        if (m!=ver || m.column(0)!=viewer || col_viewer!=viewer) 
                cout << "VectorViewTest failed !! ----------------" << endl;
        else 
                cout << "VectorViewTest passed !! ----------------" << endl;
        
}

void VectorViewTest2()
{
        cout << "VectorViewTest2 ----------------------------" << endl;
        matrix m1(10,10);
        matrix m2(10,10);
        vector v(10);
        int i;

        for (i=0;i<10; i++){v[i]=i*2;}

        for (i=0;i<10; i++)
        {
                m1.column(i) = v;
                m2.column(i) = v;
        }

        for (i=0;i<10; i++)
                m1.column(i) -= m2.column(i);

        cout << "Sum m1-m2 (m1==m2) : " << m1.sum() << endl;
        if (m1.sum())
        {
                cout << "VectorViewTest2 Failed !! (operator -= ?) " << endl;
                exit(-1);
        }
        else 
                cout << "VectorViewTest2 Passed !! -------------------------" << endl;
}

void VectorViewTest3()
{
        vector v(10);
        vector_view view1 = v;
        vector_view view2 = v;
        view2 = view1;
}
//some test calls to gsl:
void 
gsl_function_call_test()
{
        int size=5;
        matrix m(size,size);
        for (int i=0;i<size;i++)
                for (int j=0;j<size;j++)
                        m(i,j) = (i+1)*(j+1);
        double lndet = gsl_linalg_LU_lndet(m.gslobj());
        cout << "m = " << m << endl;
        cout << "lndet(m) = " << lndet << endl;

        gsl::vector sol(size);
        for (int k=0;k<size;k++)
                sol[k]=k+1;
        cout << "Solution of " << m << " x= " << sol <<endl;

        gsl::vector tau(size);
        gsl_linalg_QR_decomp(m.gslobj(), tau.gslobj());
        gsl_linalg_QR_svx(m.gslobj(), tau.gslobj(), sol.gslobj());
        
        cout << "sol= " << sol << endl;
}

void
RandomNumberGeneratorTest()
{
        cout << "RandomNumberGeneratorTest -------------------" << endl;
        random_generator generator; // default constructor takes seed from ENV variable
        int nSamples=10000;
        gsl::vector samples(nSamples);
        for (int i=0;i<nSamples;i++)
                samples[i] = generator.uniform();

        double mean=samples.sum()/(float)nSamples;
        cout << "Mean of sampling : " <<  mean << endl;
        // should be close to 0.5
        if (mean <0.51 && mean >0.49)
                cout << "RandomNumberGeneratorTest Passed !! -------------" << endl;
        else 
        {
                cout << "RandomNumberGeneratorTest Failed !! -------------" << endl;
                exit(-1);
        }
}

int main( int argc, char **argv )
{
     matrix a( 3, 3 );
     matrix b( 3, 3 );
     srand48(10);

     int i, j;
     for(i=0;i<a.size1();i++)
           for(j=0;j<a.size2();j++) a(i,j)=drand48();
     for(i=0;i<b.size1();i++)
           for(j=0;j<b.size2();j++) b(i,j)=drand48();

     cout << "a:" << endl << a << endl;
     cout << "b:" << endl << b << endl;

     cout << "a + b:" << endl << a + b << endl;
     cout << "a - b:" << endl << a - b << endl;
     cout << "a + 1.0:" << endl << a + 1.0 << endl;
     cout << "1.0 - a:" << endl << 1.0 - a << endl;
     cout << "a * 10.0:" << endl << a * 10.0 << endl;
     cout << "10.0 * a:" << endl << 10.0 * a << endl;
     cout << "a / 10.0:" << endl << a / 10.0 << endl;
     cout << "a * b:" << endl << a * b << endl;
     cout << "a.LU_decomp():" << endl << a.LU_decomp() << endl;
     cout << "a.LU_invert():" << endl << a.LU_invert() << endl;
     cout << "a.LU_invert() * a:" << endl << a.LU_invert() * a << endl;

     // call class test functions (there should be one per class)
         vector_float_test();
         gsl_function_call_test();
     VectorViewTest();
         RandomNumberGeneratorTest();
         VectorViewTest2();
         VectorViewTest3();
}

---