CenterFocusTestUnit.h

Go to the documentation of this file.

        #ifndef STRUDEL_TEST_H
#define STRUDEL_TEST_H


#include "fast_Ring.h"
// #include "eps/finite_field.h"



// Parameter 1 : Eingabedatei 
// Ausgabe als extra Funktion


using namespace std;

namespace nCenterFocus
{
// forward declaration:
int centerfocus(int argc, const char* argv[]);



//------------------------------------------------------------------------------------------------------------------------

template<class TPolynomdefs>
void templatedPolynomDefsSingleTest(TPolynomdefs &defs)
{
        int indexArray[defs.getSize() ];

        int index;
        for (int currIndex=0; currIndex < defs.getSize() ; currIndex++)
        {
                indexArray[currIndex]=0;
        }

        for (int currDegree=0; currDegree <= defs.maxdegree_m; currDegree++)
        {
                for (int yexp=0; yexp <= currDegree; yexp++)
                {
                        index = defs.getPairIndex(currDegree-yexp,yexp);
                        assert( index< defs.getSize() );
                        assert( indexArray[ index ] == 0 );
                        indexArray[ index ] = 1 ;
                }
        }
}

template<template<int> class  TPolynomdefs>
void testStaticPolynomDefs()
{

        cerr << "testPolynomDefs        " << endl;

        TPolynomdefs<0> defs0;
        TPolynomdefs<1> defs1;
        TPolynomdefs<2> defs2;
        TPolynomdefs<3> defs3;
        TPolynomdefs<4> defs4;

        templatedPolynomDefsSingleTest(defs0);
        templatedPolynomDefsSingleTest(defs1);
        templatedPolynomDefsSingleTest(defs2);
        templatedPolynomDefsSingleTest(defs3);
        templatedPolynomDefsSingleTest(defs4);


        /*
        cerr << "nextpow2num<3>::value" << nextpow2num<3>::value << endl;
        cerr << " 3 <<needbits<3>::value |3 " << (3 <<needbits<3>::value |3) +1 << endl;
        cerr << " defs3.size " <<  defs3.size  << endl;
        cerr << "nextpow2num<4>::value" << nextpow2num<4>::value << endl;
        cerr << "needbits<3>::value" << needbits<3>::value << endl;
        cerr << "needbits<4>::value" << needbits<4>::value << endl;
        cerr << " 4 <<needbits<4>::value |4 " << (4 <<needbits<4>::value |4 ) +1 << endl;
        cerr << " defs4.size " <<  defs4.size  << endl;
        */
}
template< class  TPolynomdefs>
void testDynamicPolynomDefs()
{
        cerr << "testDynamicPolynomDefs " << endl;

        TPolynomdefs defs0(0);
        TPolynomdefs defs1(1);
        TPolynomdefs defs2(2);
        TPolynomdefs defs3(3);
        TPolynomdefs defs4(4);

        templatedPolynomDefsSingleTest(defs0);
        templatedPolynomDefsSingleTest(defs1);
        templatedPolynomDefsSingleTest(defs2);
        templatedPolynomDefsSingleTest(defs3);
        templatedPolynomDefsSingleTest(defs4);
}

void testAllStaticPolynomDefs()
{
        testStaticPolynomDefs< polynomdefs >();
        testStaticPolynomDefs< polynomdefsNoShift >();
        testStaticPolynomDefs< polynomdefsNew >();
        testStaticPolynomDefs< polynompairdefs >();
}

void testAllDynamicPolynomDefs()
{
        testDynamicPolynomDefs< dynamicPolynomdefsNoShift >();
        testDynamicPolynomDefs< dynamicPolynomdefsNoShiftNoMemoryHoles >();
        //testDynamicPolynomDefs< polynomdefsNew >();
}


void testAllPolynomDefs()
{
        testAllStaticPolynomDefs();
        testAllDynamicPolynomDefs();
}

//------------------------------------------------------------------------------------------------------------------------

bool testTrim()
{
        return (                trim( string( " D D ") ).compare( string("D D") )==0 
                        &&      trim( string( "nothing to trim") ).compare(string("nothing to trim"))==0  
                        &&      ltrim( string( " D D ") ).compare( string("D D ") )==0
                        &&      rtrim( string( " D D ") ).compare( string(" D D") )==0
                );
}
//------------------------------------------------------------------------------------------------------------------------
bool testExample()
{
                
        int _argc = 4;

        const char** _argv= new  const char*[_argc+1];
        
        //std::stringstream sstream;
        //sstream << characteristic;
        
        _argv[0]="centerfocus";
        _argv[1]="+";
        _argv[2]="output";
        //_argv[2]=(char*) sstream.str().c_str(); so geht es definitiv nicht - wieso nicht?

std::stringstream pstream;

#ifdef OPTIMIZED_FIELD
        pstream << FIELDCHAR;
#else
        pstream << 29;
#endif

        _argv[3]        =       (string("-- TestExample         \n\
                                p       = ")+pstream.str()+string(";    \n\
                                minNullen       = 9;    -- search for examples where first 'minNullen' focal values vanishes\n \
                                minJRank        = 9;    -- search for examples where jacobian matrix has a rank greater or equal to 'minRank'\n \
                                minJSubMatrixRank = 9;  -- search for examples where jacobian matrix has a rank greater or equal to 'minRank'\n \
                                jacobi  = true;         -- perform jacobi matrix rank check (true/false)\n \
                                jacobiUnterMatrix       = false;        --\n\
                                anzZufall       = 1;    -- number of random experiments to perform\n\
                                grad    = 3;    -- maximal polynomial degree of p,q\n\
                                epsilon         = true;         -- compute with epsilon\n\
                                epsPrecision    = 1;    -- epsilon precision size (currenly only 0 and 1 supported)\n\
                                randomSeed      = -30;  -- starting random seed, see 'zeitAlsZufall'\n\
                                rechneBisMaxStrudel     = false;        -- 'false': abort focal values computation of a example if a value does not vanish; 'true': compute all 'maxStrudel' focal values\n\
                                benutzeFormel1  = true;         -- compute q(3,0) in a kind that first focal value vanish\n\
                                benutzeFormel2  = true;         -- compute p(3,0) in a kind that second focal value vanish\n\
                                hamilton        = true;         -- true: don't filter Hamilton components\n\
                                zeitAlsZufall   = false;        -- false: use inital seed for random function given in 'zufallInit'; true: use timer as initial seed\n\
                                \n\
                                \n\
                                L = { { {\n\
                                                        {27, 9, 22},            \n\
                                                        {3, 8, 5},              \n\
                                                        {11, 20, 4, 3},         \n\
                                                        {3, 25, 20, 18}         \n\
                                                }\n\
                                        }\n\
                                } \n ")).c_str();

        centerfocus(_argc,_argv);
        //exit(0);
        return false;
}


bool testParameterParser01()
{
                
        int _argc = 4;

        const char** _argv= new  const char*[_argc+1];
        
        //std::stringstream sstream;
        //sstream << characteristic;
        
        _argv[0]="centerfocus";
        _argv[1]="+";
        _argv[2]="output";
        //_argv[2]=(char*) sstream.str().c_str(); so geht es definitiv nicht - wieso nicht?
        
std::stringstream pstream;

#ifdef OPTIMIZED_FIELD
        pstream << FIELDCHAR;
#else
        pstream << 29;
#endif
string arg3(string("-- TestExample      \n\
                                p       = ") +pstream.str()+string(";   \n\
                                minNullen       = 9;    -- search for examples where first 'minNullen' focal values vanishes\n \
                                minJRank        = 9;    -- search for examples where jacobian matrix has a rank greater or equal to 'minRank'\n \
                                minJSubMatrixRank = 9;  -- search for examples where jacobian matrix has a rank greater or equal to 'minRank'\n \
                                jacobi  = true;         -- perform jacobi matrix rank check (true/false)\n \
                                jacobiUnterMatrix       = false;        --\n\
                                anzZufall       = 1;    -- number of random experiments to perform\n\
                                grad    = 3;    -- maximal polynomial degree of p,q\n\
                                epsilon         = true;         -- compute with epsilon\n\
                                epsPrecision    = 5;    -- epsilon precision size (currenly only 0 and 1 supported)\n\
                                randomSeed      = -30;  -- starting random seed, see 'zeitAlsZufall'\n\
                                rechneBisMaxStrudel     = false;        -- 'false': abort focal values computation of a example if a value does not vanish; 'true': compute all 'maxStrudel' focal values\n\
                                benutzeFormel1  = true;         -- compute q(3,0) in a kind that first focal value vanish\n\
                                benutzeFormel2  = false;        -- compute p(3,0) in a kind that second focal value vanish\n\
                                hamilton        = true;         -- true: don't filter Hamilton components\n\
                                zeitAlsZufall   = false;        -- false: use inital seed for random function given in 'zufallInit'; true: use timer as initial seed\n\
                                ergebnisDatenAnhaengen  = true;-- \n\
                                \n\
                                \n\
                                L = { { {\n\
                                                        {27, 9, 22},            \n\
                                                        {3, 8, 5},              \n\
                                                        {11, 20, 4, 3},         \n\
                                                        {3, 25, 20, A}  \n\
                                                }\n\
                                        }\n\
                                } ;\n ")) ;

          char * a = new char [arg3.size()];

        strcpy(a, arg3.c_str() );
        
        _argv[3] = a;

        D_CenterfocusParams* params= new D_CenterfocusParams(_argc, _argv);
        assert( params->inputFromStd()==false); 
#ifdef OPTIMIZED_FIELD
         
assert( params->getFieldCharacteristic()==FIELDCHAR );
#else
assert( params->getFieldCharacteristic()==29 );
#endif
        

        assert( params->getEpsPrecision()==5 );
        
        assert( params->getRequestedTrialsNum()==1 );

        assert( params->getPolynomialDegree()==3 );

        //assert( params->checkJacobianRank()==true );

        assert( params->getMaxFocalValuesToCompute()== (params->getFieldCharacteristic() - 1 )/2 -1 );

        assert( params->getRequiredFullJacobianMinRank()==9 );

        assert( params->requiredVanishedFocalValuesNum()==9 );

        assert( params->getRandomSeedRef()==-30 );

        assert(*(params->getRandomSeedPtr() )==-30 );

        assert( params->bInitRandomFromTime()==false );

        assert( params->useFormula1()==true );

        assert( params->useFormula2()==false );

 

//      assert( params->computeQuadric()==true );

        //assert( params->filterHamilton()==false );

        //assert ( params->computeAllFocalValues()==false ); // = rechne bis MaxStrudel

        //assert( params->jacobiSubMatrix()==false ); 

        assert( params->readNextPolynoms()==true );

        assert( params->polynomsHaveRandomCoeff()==false );     

        assert( params->polynomsHaveCheckAllCoeff()==true );    

         D_CenterfocusParams::PolynomXY_Type  minusPolynomp = params->getMinusPPolynomRef();

         D_CenterfocusParams::PolynomXY_Type::CoefficientType coeff (params->getRing()->getField()->Convert(27) );

        assert((int) coeff.getX()==(params->getRing()->getField()->Convert(27)) );

        const D_CenterfocusParams::RingType * ring = params->getRing();

        assert(minusPolynomp.getCoeff( 2,0 ) == ring->addInv(coeff) );

        coeff.setX(22);

        assert(   minusPolynomp.getCoeff( 0,2 )  == ring->addInv(coeff) );

        coeff.setX(11);
        assert(   minusPolynomp.getCoeff( 3,0 )  == ring->addInv(coeff) );


        cerr << " -- Test " << __FUNCTION__ << " passed !" << endl;
        return true;
}


template<class FrommerType>
void frommer_TestNo1(FrommerType & frommer)
{
        const typename  FrommerType::RingType & ring = frommer.getRingRef();

        string  minusP_String(" { {-1, 0}, {4, 0, 1} }");
        string  q_String(" { {0,1}, {1, 0, -2} }");

        

        typename FrommerType::TPolynomXY
        minus_polynom_P         = createFromString<typename  FrommerType::TPolynomXY>( minusP_String, ring);

        typename FrommerType::TPolynomXY
        polynom_Q               = createFromString<typename  FrommerType::TPolynomXY>( q_String, ring);

        std::cerr << "minusP_String" << minusP_String << endl;
        std::cerr << "minus_polynom_P" << minus_polynom_P << endl;
        
        std::cerr << "q_String" << q_String << endl;
        std::cerr << "polynom_Q" << polynom_Q << endl;

        frommer.setPolynoms( &minus_polynom_P , & polynom_Q );
        frommer.doit(false);
        
        typename FrommerType::TPolynomXY::CoefficientType  firstFocalValue = frommer.getFocalValue(1);
        
        //cerr << "firstFocalValue: " << firstFocalValue << endl;
        assert(firstFocalValue== ring.Convert(4) );
}


template<class FrommerType>
void frommer_TestNo2(FrommerType & frommer)
{
        const typename  FrommerType::RingType & ring = frommer.getRingRef();
        

        string  minusP_String(" { {-1, 0}, {-1, -2, 1} }");
        string  q_String(" { {0,  1}, { 0, -2, 1} }");
        typename FrommerType::TPolynomXY
        minus_polynom_P         = createFromString<typename  FrommerType::TPolynomXY>(minusP_String, ring);
        
        typename FrommerType::TPolynomXY
        polynom_Q               = createFromString<typename  FrommerType::TPolynomXY>(q_String, ring);
        
        frommer.setPolynoms( &minus_polynom_P , & polynom_Q );

        frommer.doit(false);

        //2.Strudelgröße = -14/15     
        typename FrommerType::TPolynomXY::CoefficientType referenceResult = ring.addInv (       ring.multiply(ring.Convert(14), 
                                                                                                ring.multInv(ring.Convert(15).getX() ) ) 
                                                                                        );
        
        typename FrommerType::TPolynomXY::CoefficientType  secondFocalValue = frommer.getFocalValue(2);

        assert(secondFocalValue == referenceResult);
}

template<class FrommerType>
void frommer_TestNo3(FrommerType & frommer)
{
        const typename FrommerType::RingType & ring = frommer.getRingRef();
        

        string  minusP_String(" { {-1, 0}, {-4, 0, -1}, {-2, 0, 0, 2} }");
        string  q_String(" { {0, 1}, {1, 0, -2}, {2, 0, 0, -2} }");
        typename  FrommerType::TPolynomXY               
        minus_polynom_P         = createFromString<typename  FrommerType::TPolynomXY>(minusP_String, ring);

        typename  FrommerType::TPolynomXY 
        polynom_Q               = createFromString<typename  FrommerType::TPolynomXY>(q_String, ring);

        frommer.setPolynoms( &minus_polynom_P , & polynom_Q );
        frommer.doit(false);
        
        for (int currFocalValue=1; currFocalValue<=frommer.getMaxFocalValuesToCompute(); currFocalValue++)
        {
                        typename FrommerType::TPolynomXY::CoefficientType  focalValue = frommer.getFocalValue(currFocalValue);
                        assert(focalValue== ring.Convert(0) );
        }
}


template<class FrommerType>
void frommer_TestNo4_a(FrommerType & frommer)
{
        const typename  FrommerType::RingType & ring = frommer.getRingRef();
        

        string  minusP_String(" { {-1, 0}, {0, 0, 0}, {-2, 0, 0, -1} }");
        string  q_String(" { {0, 1}, {0, 0, 0}, {0, 1, 0, 1} }");
        typename  FrommerType::TPolynomXY                       
        minus_polynom_P         = createFromString<typename  FrommerType::TPolynomXY>(minusP_String, ring);

        typename  FrommerType::TPolynomXY        
        polynom_Q               = createFromString<typename  FrommerType::TPolynomXY>(q_String, ring);

        frommer.setPolynoms( &minus_polynom_P , & polynom_Q );
        frommer.doit(false);
        
        
        typename FrommerType::TPolynomXY::CoefficientType  focalValue = frommer.getFocalValue(1);
        assert(focalValue==ring.addInv( ring.Convert(1).getX() ) );
        
}


template<class FrommerType>
void frommer_TestNo4_b(FrommerType & frommer)
{
        const typename  FrommerType::RingType & ring = frommer.getRingRef();
        

        string  minusP_String(" { {-1, 0}, {0, 0, 0}, {0, -4, 0, -1} }");
        string  q_String(" { {0, 1}, {0, 0, 0}, {2, 0, 1, 0} }");
        typename  FrommerType::TPolynomXY                       
        minus_polynom_P         = createFromString<typename  FrommerType::TPolynomXY>(minusP_String, ring);

        typename  FrommerType::TPolynomXY        
        polynom_Q               = createFromString<typename  FrommerType::TPolynomXY>(q_String, ring);

        frommer.setPolynoms( &minus_polynom_P , & polynom_Q );
        frommer.doit(false);
        
        //1. Strudelgroese = 44/35      
        typename FrommerType::TPolynomXY::CoefficientType referenceResult =     ring.multiply(  ring.Convert(44), 
                                                                                                                                ring.multInv(ring.Convert(35).getX() )  
                                                                                                                        );
        cerr << "ring.Convert(44) " << ring.Convert(44) << endl;
        cerr << "ring.multInv(ring.Convert(35) ) " << ring.multInv(ring.Convert(35).getX() ) << endl;
        cerr << "referenceResult " << referenceResult << endl;
        typename FrommerType::TPolynomXY::CoefficientType  focalValue = frommer.getFocalValue(1);
        for (int currFocalValue=1; currFocalValue<=frommer.getComputedFocalValuesNum(); currFocalValue++)
        {
                focalValue = frommer.getFocalValue(currFocalValue);
                cerr << "focalValue " << focalValue << endl;
        }
        focalValue = frommer.getFocalValue(3);
        cerr << "focalValue " << focalValue << endl;
        assert( focalValue == referenceResult );
}
//1. Strudelgröße = 44/35


template<class FrommerType>
void frommer_TestNo5(FrommerType & frommer)
{
        const typename  FrommerType::RingType & ring = frommer.getRingRef();
        

        string  minusP_String(" { {-1, 0}, {0, 0, 0}, {0, -4, 0, -1},  {0, 0, -2, 0, 0, 0} }");
        string  q_String(" { {0, 1}, {0, 0, 0}, {2, 0, 1, 0} ,  {0, 2, 0, 0, 0 ,0} }");
        typename  FrommerType::TPolynomXY                       
        minus_polynom_P         = createFromString<typename  FrommerType::TPolynomXY>(minusP_String, ring);

        typename  FrommerType::TPolynomXY        
        polynom_Q               = createFromString<typename  FrommerType::TPolynomXY>(q_String, ring);

        frommer.setPolynoms( &minus_polynom_P , & polynom_Q );
        frommer.doit(false);
        
        
        for (int currFocalValue=1; currFocalValue<=frommer.getMaxFocalValuesToCompute(); currFocalValue++)
        {
                        typename FrommerType::TPolynomXY::CoefficientType  focalValue = frommer.getFocalValue(currFocalValue);
                        assert(focalValue==ring.Convert(0));
        }
}

template<class FrommerType>
void frommer_TestNo6(FrommerType & frommer)
{
        const typename  FrommerType::RingType & ring = frommer.getRingRef();
        

        string  minusP_String(" { {-1, 0}, { -1,0,0,0,0,0,0,0}, { 0,-2,0,0,0,0,0,0,0,0}, { 0,0,0,0,0,0,0,0,0,0,0,1} }");
        string  q_String(" { {0, 1}, { 0,-2,0,0,0,0,0,0,0,0,0,1} }");
        typename  FrommerType::TPolynomXY                       
        minus_polynom_P         = createFromString<typename  FrommerType::TPolynomXY>(minusP_String, ring);

        typename  FrommerType::TPolynomXY        
        polynom_Q               = createFromString<typename  FrommerType::TPolynomXY>(q_String, ring);

        frommer.setPolynoms( &minus_polynom_P , & polynom_Q );
        frommer.doit(false);
        
        
        typename FrommerType::TPolynomXY::CoefficientType referenceResult = ring.addInv (       ring.multiply(ring.Convert(2), 
                                                                                                ring.multInv(ring.Convert(9).getX() ) ) 
                                                                                        );
        cerr << "referenceResult " << referenceResult << endl;
        typename FrommerType::TPolynomXY::CoefficientType  focalValue = frommer.getFocalValue(1);
        for (int currFocalValue=1; currFocalValue<=frommer.getComputedFocalValuesNum(); currFocalValue++)
        {
                focalValue = frommer.getFocalValue(currFocalValue);
                cerr << "focalValue " << focalValue << endl;
        }
          focalValue = frommer.getFocalValue(4);

        assert(focalValue == referenceResult);
}
//1. Strudelgroesse = -2/9

template <class FrommerType>
void frommerTest(int characteristic, int epsPrecision)
{
        int maxFocalValuesToCompute = (characteristic-3)/2;
        typename FrommerType::RingType ring(characteristic, epsPrecision);

        FrommerType frommer(maxFocalValuesToCompute, &ring);

        
        
        frommer_TestNo1 (frommer);
        cerr << "frommer_TestNo1 test passed! " << endl;
        
        
        frommer_TestNo2 (frommer);
        cerr << "frommer_TestNo2 test passed! " << endl;
        
        frommer_TestNo3 (frommer);
        cerr << "frommer_TestNo3 test passed! " << endl;
        
        frommer_TestNo4_a       (frommer);
        cerr << "frommer_TestNo4_a test passed! " << endl;
        
        frommer_TestNo4_b       (frommer);
        cerr << "frommer_TestNo4_b test passed! " << endl;

        #ifndef OPTIMIZED_FIELD
                frommer_TestNo5 (frommer);
                cerr << "frommer_TestNo5 test passed! " << endl;
                frommer_TestNo6 (frommer);
                cerr << "frommer_TestNo6 test passed! " << endl;

        #endif
        

        cerr << "Frommer tests passed! " << endl;
}

template <class FrommerType>
void frommerTestInternal(int epsPrecision)
{

        #ifdef FIELDCHAR
                frommerTest<FrommerType>(FIELDCHAR,epsPrecision);
        #else
        std::cerr << "FIELDCHAR not defined" << std::endl;
        frommerTest<FrommerType>(11,epsPrecision);
        frommerTest<FrommerType>(23,epsPrecision);
        frommerTest<FrommerType>(29,epsPrecision);
        #endif
}


void frommerTest ()
{
        int epsPrecision=0;
        frommerTestInternal<D_Frommer>(epsPrecision=1);
        frommerTestInternal<D_Frommer0>(epsPrecision=0);
        frommerTestInternal<D_Frommer2>(epsPrecision=1);
        frommerTestInternal<D_Eps_Frommer>(epsPrecision=0);

}



// Originaltests: - ja, und was war denn die Charakteristik??? egal?

        //erstes Beispiel
        /*
        polynomXY p(2);
        p.SetKoeff(1,0,1);
        p.SetKoeff(2,0,4);
        p.SetKoeff(0,2, 1);
        polynomXY q(2);
        q.SetKoeff(0,1,1);
        q.SetKoeff(2,0,1);
        q.SetKoeff(0,2, k.negativ(2));
        //1.Strudelgröße = -4
        */

        //zweites Beispiel
        /*
        polynomXY p(2);
        p.SetKoeff(1,0, 1);
        polynomXY q(2);
        q.SetKoeff(0,1,1);
        p.SetKoeff(2,0, 1);
        p.SetKoeff(1,1, 2);
        p.SetKoeff(0,2, k.negativ(1));
        q.SetKoeff(1,1, k.negativ(2));
        q.SetKoeff(0,2, 1);
        //2.Strudelgröße = -14/15
        */

        //drittes Beispiel
        /*
        polynomXY p(3);
        p.SetKoeff(1,0, 1);
        p.SetKoeff(2,0, 4);
        p.SetKoeff(0,2, 1);
        p.SetKoeff(3,0, 2);
        p.SetKoeff(0,3, k.negativ(2));
        polynomXY q(3);
        q.SetKoeff(0,1, 1);
        q.SetKoeff(2,0, 1);
        q.SetKoeff(0,2, k.negativ(2));
        q.SetKoeff(3,0, 2);
        q.SetKoeff(0,3, k.negativ(2));
        */
        //alle Strudelgrößen = 0
        

        //viertes Beispiel
        /*
        polynomXY p(3);
        p.SetKoeff(1,0, 1);
        p.SetKoeff(3,0, 2);
        p.SetKoeff(0,3, 1);
        polynomXY q(3);
        q.SetKoeff(0,1, 1);
        q.SetKoeff(2,1, 1);
        q.SetKoeff(0,3, 1);
        */
        //1. Strudelgröße = -1

        //viertes Beispiel
        /*
        polynomXY p(3);
        p.SetKoeff(1,0, 1);
        p.SetKoeff(2,1, 4);
        p.SetKoeff(0,3, 1);
        polynomXY q(3);
        q.SetKoeff(0,1, 1);
        q.SetKoeff(3,0, 2);
        q.SetKoeff(1,2, 1);
        */
        //1. Strudelgröße = 44/35

        //fünftes Beispiel
        /*
        polynomXY p(5);
        p.SetKoeff(1,0, 1);
        p.SetKoeff(2,1, 4);
        p.SetKoeff(0,3, 1);
        p.SetKoeff(3,2, 2);
        polynomXY q(5);
        q.SetKoeff(0,1, 1);
        q.SetKoeff(3,0, 2);
        q.SetKoeff(1,2, 1);
        q.SetKoeff(4,1, 2);
        */
        //alle Strudelgrößen = 0

        //sechstes Beispiel
        /*
        polynomXY p(11);
        p.SetKoeff(1,0, 1);
        p.SetKoeff(7,0, 1);
        p.SetKoeff(8,1, 2);
        p.SetKoeff(0,11, k.negativ(1));
        polynomXY q(11);
        q.SetKoeff(0,1, 1);
        q.SetKoeff(10,1, k.negativ(2));
        q.SetKoeff(0,11, 1);
        //1. Strudelgröße = -2/9
        */

};

#endif