Tests.h

Go to the documentation of this file.

#ifndef TEST_H
#define TEST_H


// todo: Kommandozeilen-Parser
// Parameter 1 : Eingabedatei 
// Ausgabe als extra Funktion


using namespace std;

void test_template_functions()
{
        assert (pow2<1>::value == 2);
        assert (pow2<2>::value == 4);
        assert (pow2<3>::value == 8);
        assert (pow2<4>::value == 16);
        assert (pow2<5>::value == 32);
        assert (pow2<6>::value == 64);
        assert (pow2<7>::value == 128);
        assert (pow2<8>::value == 256);
        assert (pow2<9>::value == 512);
        assert (pow2<10>::value == 1024);


        assert (nextpow2num<7>::value   == 8);
        assert (nextpow2num<8>::value   == 16);
        assert (nextpow2num<23>::value  == 32);
        assert (nextpow2num<32>::value  == 64);
        assert (nextpow2num<33>::value  == 64);
        assert (nextpow2num<197>::value == 256);

        assert (needbits<7>::value  == 3);
        assert (needbits<8>::value  == 4);
        assert (needbits<23>::value == 5);
        assert (needbits<32>::value == 6);
        assert (needbits<33>::value == 6);
        assert (needbits<197>::value== 8);

}


template <typename TRing>
void manual_test()
{
        int charakteristic = 29;
        int epsPrecision   =  1;
        TRing ring = new TRing( charakteristic, epsPrecision);
        typename TRing::ElementType element(28,27);
        std::cerr << "add " << element <<"," << element ;
        typename TRing::ElementType result;
        result = ring->add(element,element);
        std::cerr << " results in " << result << std::endl;
        std::cerr << "multiply " << element <<"," << element ;
        result = ring->multiply(element,element);
        std::cerr << " results in " << result << std::endl;

        return;
}


template <int CHAR>
void testEpsRing(int epsPrecision)
{
}



template <typename TRing>
void testRing(unsigned int characteristic, unsigned short epsPrecision=1)
{
        cerr << "characteristic" << characteristic<< endl;
        TRing* ring= new TRing(characteristic, epsPrecision);

        for (unsigned int i=0; i<characteristic; i++)
        {
                assert(ring->addInv(i).getX()==(-i+characteristic) % characteristic);
                for (unsigned int j=0; j<characteristic; j++)
                {
                        assert(ring->add(i,j).getX()     == ((i+j)  % characteristic));
                        assert(ring->multiply(i,j).getX()== ((i*j)  % characteristic));

                        if (ring->multiply(i,j) ==  TRing::ElementType::One)
                        {
                                        assert(ring->multInv(i).getX()==j);
                        }
                }
        }
        if (epsPrecision==1)
        {
                for (unsigned int i=0;i<characteristic;i++)
                {
                        for (unsigned int j=0;j<characteristic;j++)
                        {
                                for (unsigned int k=0;k<characteristic;k++)
                                {
                                        for (unsigned int l=0;l<characteristic;l++)
                                        {
                                                typename TRing::ElementType  a(i,j);
                                                typename TRing::ElementType  b(k,l);
                                                assert(ring->addInv(a).getX()  ==(-i+characteristic)% characteristic);
                                                assert(ring->addInv(a).getEps()==(-j+characteristic)% characteristic);
        
                                                assert(ring->add(a,b).getX()  ==((i+k)%characteristic));
                                                assert(ring->add(a,b).getEps()==((l+j)%characteristic));
        
                                                assert(ring->multiply(a,b).getX()  == ((i*k)    % characteristic));
                                                assert(ring->multiply(a,b).getEps()== ((i*l+j*k)% characteristic));
                                        }
                                }
                        }
                }
        }
        
        delete ring;
        std::cerr << "--Partly tested: fast_Ring  operations with charakteristic=" 
             << characteristic << "and epsPrecision= " << epsPrecision << std::endl;
}



template <template<class a, class b> class  TRing, typename TScalar, class TScaparPair , int characteristic, int epsPrecision>
void tt_autotest()
{
        typedef  kdefs_zahl_x<7,0>  kdefs_dummy;

        typedef  fast_Ring< number_eps0< characteristic, TScalar> ,kdefs_dummy >        TR1;

        typedef  fast_Ring< fieldScalar< TScalar> , kdefs_dummy >       TdR0;

        if (characteristic<50)
        {
                typedef  TRing< number_eps1< characteristic, TScalar, TScaparPair> ,kdefs_dummy >       TR0;
                typedef  fast_Ring< basicNumber< TScalar > , kdefs_dummy >      TdR1;
                testRing<TR0>(characteristic,0);
                testRing<TdR1>(characteristic,0);
        }
        testRing<TR1>(characteristic,0);
        testRing<TdR0>(characteristic,0);
        
}

template <typename TScalar, class TScaparPair>
void tautotest()
{
        test_template_functions();
        typedef  kdefs_zahl_x<7,0>  kdefs_dummy;

        tt_autotest<fast_Ring,TScalar,TScaparPair,7,0>();
        tt_autotest<fast_Ring,TScalar,TScaparPair,11,0>();
        tt_autotest<fast_Ring,TScalar,TScaparPair,13,0>();
        tt_autotest<fast_Ring,TScalar,TScaparPair,17,0>();
        tt_autotest<fast_Ring,TScalar,TScaparPair,19,0>();
        tt_autotest<fast_Ring,TScalar,TScaparPair,29,0>();
        // hmm,sobald man tt_autotest hinschreibt, wird initialisiert...wieso???
        //tt_autotest<fast_Ring,TScalar,TScaparPair,197,0>();

        return;
}

void autotest()
{
        tautotest<unsigned char,short>();
        tautotest<short,short>();
}



void testRandom(int characteristic)
{
        std::cerr << "-- Random Generator Test" << std::endl;
        std::cerr << "--------------------" << std::endl;
        std::cerr << "-- seed from Systime" << std::endl;
        std::cerr << "-- characteristic: " << characteristic  << std::endl;
        int array[characteristic];
        int value;
        
        for  (int i=0;i<characteristic;i++) // durchlaufe die komplette Liste
        {
                array[i]=0;
        }
        long seed = -30;

        time_t tt;
        time(&tt);
        seed = (tt);

        long trials=10000000;
        for  (long i=0;i<trials;i++) // durchlaufe die komplette Liste
        {
                value =random(&seed,characteristic-1);
                assert(value>=0 && value<characteristic);
                array[value]++;
        }
        long average =(long)trials/(characteristic*1.0);
        double maxError=0;
        /*for  (int i=0;i<characteristic;i++) // durchlaufe die komplette Liste
        {
                std::cerr << " [" << i << "]= " << array[i] << std::endl;
        }*/
        for  (int i=0;i<characteristic;i++) // durchlaufe die komplette Liste
        {

                //std::cerr << "abs(average-array[i])/average *1.0"<<(double) abs(average-array[i])/(average *1.0) << std::endl;
                if (maxError<(double)abs(average-array[i])/(average *1.0))
                        maxError=abs(average-array[i])/(average*1.0);
                //cerr << "average"<< average  << endl;
                //cerr <<"average-array[i]" <<average-array[i]  << endl;
                assert(abs(average-array[i]) < average*0.006 );  // fünf Promille Abweichung...
        }
        
        std::cerr << "--Random Generator test finished" << std::endl;
        std::cerr << "--maxError: " << maxError<< std::endl;
 
}



#endif