polynomialRing.cpp

Go to the documentation of this file.

template<class TPolynomXY, class TRing>
PolynomialRing<TPolynomXY, TRing>::PolynomialRing(const TRing & ring): ring_ref_m(ring)
        {
        }


template<class TPolynomXY, class TRing>
TPolynomXY              PolynomialRing<TPolynomXY, TRing>::addInv        (const TPolynomXY      & _polynom_ref) const
{

        TPolynomXY  res(_polynom_ref.getDegree() );
        
        for (short  i=0; i<= _polynom_ref.getDegree(); i++)
                {
                        for(short j=0; j<=i; j++)
                        {
                                res.setCoeff (i-j, j , ring_ref_m.addInv( _polynom_ref.getCoeffConst(i-j, j) ) );
                                #ifdef COUNT
                                        addCount+=1;
                                #endif
                        }
                }
        return res;
}


template<class TPolynomXY, class TRing>
TPolynomXY*             PolynomialRing<TPolynomXY, TRing>::addInvReturnPtr(const        TPolynomXY      & _polynom_ref  ) const
{
        TPolynomXY * res= new TPolynomXY(_polynom_ref.getDegree() );
        
        for (short  i=0; i<= _polynom_ref->getDegree(); i++)
                {
                        for(short j=0; j<=i; j++)
                        {
                                res->setCoeff (i-j, j , ring_ref_m.addInv( _polynom_ref.getCoeffConst(i-j, j) ) );
                                #ifdef COUNT
                                        addCount+=1;
                                #endif
                        }
                }
        return res;
}


template<class TPolynomXY, class TRing>
        void                    PolynomialRing<TPolynomXY, TRing>::addInvInPlace(       TPolynomXY      & _polynom_ref  ) const
{

        for (short  i=0; i<= _polynom_ref->getDegree(); i++)
                {
                        for(short j=0; j<=i; j++)
                        {
                                ring_ref_m.addInvInPlace( _polynom_ref.getCoeffRef(i-j, j) );
                                #ifdef COUNT
                                        addCount+=1;
                                #endif
                        }
                }
        return ;
}


template<class TPolynomXY, class TRing>
TPolynomXY              PolynomialRing<TPolynomXY, TRing>::add(const TPolynomXY & _polynom_1_ref,
                                                                                const TPolynomXY & _polynom_2_ref) const
{

        // add polynoms for different Degree currently not implemented.
        assert(_polynom_1_ref.getDegree()==_polynom_2_ref.getDegree() );

        const short resDegree= max(_polynom_1_ref.getDegree(),_polynom_2_ref.getDegree() );
        TPolynomXY  res (resDegree );
        //i-j is the x-exp and j is the y-exp., i is the currentMonomDegree
        for (short  currMonomDegree=0; currMonomDegree<= resDegree; currMonomDegree++)
                {
                        for(short yExp=0; yExp<=currMonomDegree; yExp++)
                        {
                                short xExp = currMonomDegree - yExp;

                                res.setCoeff (xExp, yExp , ring_ref_m.add(      _polynom_1_ref.getCoeffConst(xExp, yExp ),
                                                                                _polynom_2_ref.getCoeffConst(xExp, yExp ) 
                                                                )
                                                        );
                                #ifdef COUNT
                                        addCount+=1;
                                #endif
                        }
                }
        return res;
}

template<class TPolynomXY, class TRing>
TPolynomXY*     PolynomialRing<TPolynomXY, TRing>::addReturnPtr( const  TPolynomXY       & _polynom_1_ref,
                                                                                        const   TPolynomXY       & _polynom_2_ref) const
{
// add polynoms for different Degree currently not implemented.
        assert(_polynom_1_ref.getDegree()==_polynom_2_ref.getDegree() );

        const short resDegree= max(_polynom_1_ref.getDegree(),_polynom_2_ref.getDegree);
        TPolynomXY *  res = new TPolynomXY(resDegree );
        //i-j is the x-exp and j is the y-exp., i is the currentMonomDegree
        for (short  currMonomDegree=0; currMonomDegree<= resDegree; currMonomDegree++)
                {
                        for(short yExp=0; yExp<=currMonomDegree; yExp++)
                        {
                                short xExp = currMonomDegree - yExp;

                                res->setCoeff (xExp, yExp , ring_ref_m.add(     _polynom_1_ref.getCoeffConst(xExp, yExp ),
                                                                                _polynom_2_ref.getCoeffConst(xExp, yExp ) 
                                                                )
                                                        );
                                #ifdef COUNT
                                        addCount+=1;
                                #endif
                        }
                }
        return res;
}


template<class TPolynomXY, class TRing>
inline void                     PolynomialRing<TPolynomXY, TRing>::addInPlace(  TPolynomXY                      & _polynom_1_ref,
                                                                                        const TPolynomXY                & _polynom_2_ref) const
{
        // add polynoms for different Degree currently not implemented.
        assert(_polynom_1_ref.getDegree() == _polynom_2_ref.getDegree() );

        //i-j is the x-exp and j is the y-exp., i is the currentMonomDegree
        for (short  currMonomDegree=0; currMonomDegree<= _polynom_1_ref.getDegree(); currMonomDegree++)
                {
                        for(short yExp=0; yExp<=currMonomDegree; yExp++)
                        {
                                short xExp = currMonomDegree - yExp;

                                        ring_ref_m.addInPlace(  _polynom_1_ref.getCoeffRef(xExp, yExp ),
                                                        _polynom_2_ref.getCoeffConst(xExp, yExp ) 
                                                        );
                                #ifdef COUNT
                                        addCount+=1;
                                #endif
                        }
                }
        return ;
}


template<class TPolynomXY, class TRing>
TPolynomXY              PolynomialRing<TPolynomXY, TRing>::scalarMultiply(const typename TPolynomXY::CoefficientType    scalar,
                                                                                 const  TPolynomXY                      & _polynom_ref) const
{
        TPolynomXY  res( _polynom_ref.getDegree() );
        //i-j is the x-exp and j is the y-exp., i is the currentMonomDegree
        for (short  currMonomDegree=0; currMonomDegree<= _polynom_ref.getDegree(); currMonomDegree++)
                {
                        for(short yExp=0; yExp <= currMonomDegree; yExp++)
                        {
                                short xExp = currMonomDegree - yExp;

                                res.setCoeff (xExp, yExp , ring_ref_m.scalarMultiply(   scalar,
                                                                                        _polynom_ref.getCoeffConst( xExp, yExp ) 
                                                        )
                                        );
                                #ifdef COUNT
                                        addCount+=1;
                                #endif
                        }
                }
        //short polynomDegree = _polynom_ref.getDegree()
        //short xexp,yexp, currDegree;
        // begin(xexp,yexp,currDegree, polynomDegree);
        // while (next (xexp,yexp,polynomDegree))
        //for (begin(xexp,yexp,polynomDegree); !end(currDegree, polynomDegree);  next (xexp, yexp, currDegree, polynomDegree))
        //      res.setCoeff (xExp, yExp , ring_ref_m.scalarMultiply(   scalar,
        //                                                                              _polynom_ref.getCoeffConst( xExp, yExp ) 
        //                                              )
        //                              );
        return res;
}


/*
// so ungefähr könnte man es mit dem Durchlaufen der Monome machen: begin() und next()
// da brauchst du aber strenggenommen eine const-iterator, einen Ref-Iterator und einen normalen Iterator
inline bool begin(short & xexp, short & yexp , short currDegree, int polynomialDegree)
{ 
        currDegree = 0;
        xexp = 0;
        yexp = 0;
        return ( polynomialDegree>=0 );
}

inline bool end(  short & currDegree, int polynomialDegree)
{ 
        return  (currDegree<=polynomialDegree);
}

// so ungefähr könnte man ex machen.
inline bool nextMonomExp(short & xexp, short & yexp, short &currDegree, int polynomialDegree)
{
        //short currDegree = xexp + yexp;
        if (yexp<currDegree)
        {
                yexp++;
                xexp--;
        }
        else 
        {
                currDegree++;
                xexp=currDegree;
                yexp=0;
                if (currDegree>polynomialDegree)
                        return false;
        }
        return true;

}*/

template<class TPolynomXY, class TRing>
void            PolynomialRing<TPolynomXY, TRing>::scalarMultiplyInPlace(const typename TPolynomXY::CoefficientType     scalar,
                                                                                TPolynomXY                              & _polynom_ref  ) const
{
 
        //i-j is the x-exp and j is the y-exp., i is the currentMonomDegree
        for (short  currMonomDegree=0; currMonomDegree<= _polynom_ref.getDegree(); currMonomDegree++)
                {
                        for(short yExp=0; yExp <= currMonomDegree; yExp++)
                        {
                                short xExp = currMonomDegree - yExp;

                                /*_polynom_ref.setCoeff (xExp, yExp , ring_ref_m.scalarMultiply(        scalar,
                                                                                                _polynom_ref.getCoeffConst( xExp, yExp ) 
                                                        )
                                        );*/
                                         ring_ref_m.scalarMultiplyInPlace(scalar, _polynom_ref.getCoeffRef (xExp, yExp) );

                                #ifdef COUNT
                                        addCount+=1;
                                #endif
                        }
                }
}

template<class TPolynomXY, class TRing>
TPolynomXY*     PolynomialRing<TPolynomXY, TRing>::scalarMultiplyRetPtr(const   typename TPolynomXY::CoefficientType    scalar,
                                                                                const   TPolynomXY                      & _polynom_ref) const
{
        
        TPolynomXY*  res = new TPolynomXY( _polynom_ref.getDegree() );
        //i-j is the x-exp and j is the y-exp., i is the currentMonomDegree
        for (short  currMonomDegree=0; currMonomDegree<= _polynom_ref.getDegree(); currMonomDegree++)
                {
                        for(short yExp=0; yExp <= currMonomDegree; yExp++)
                        {
                                short xExp = currMonomDegree - yExp;

                                res->setCoeff (xExp, yExp , ring_ref_m.scalarMultiply(  scalar,
                                                                                        _polynom_ref.getCoeffConst( xExp, yExp ) 
                                                        )
                                        );
                                #ifdef COUNT
                                        addCount+=1;
                                #endif
                        }
                }
        //short polynomDegree = _polynom_ref.getDegree()
        //short xexp,yexp, currDegree;
        // begin(xexp,yexp,currDegree, polynomDegree);
        // while (next (xexp,yexp,polynomDegree))
        //for (begin(xexp,yexp,polynomDegree); !end(currDegree, polynomDegree);  next (xexp, yexp, currDegree, polynomDegree))
        //      res.setCoeff (xExp, yExp , ring_ref_m.scalarMultiply(   scalar,
        //                                                                              _polynom_ref.getCoeffConst( xExp, yExp ) 
        //                                              )
        //                              );
        return res;
}

template<class TPolynomXY, class TRing>
template <class TPolynomXY_SRC_Type, class TPolynomXY_DEST_Type>
void    PolynomialRing<TPolynomXY, TRing>::copyPolynomWithGivenEpsPrecision(const TPolynomXY_SRC_Type  & srcPol,
                                                                         TPolynomXY_DEST_Type   &        destPol, int epsPrecision)
{       
        //assert((&srcPol) != (&destPol)) ;

        for (int deg = srcPol.getDegree(); deg>=0; deg--)
        {
                for (int x_exp=deg; x_exp>=0; x_exp--)
                {
                        int MaxEpsPrecision= min(epsPrecision, (int)srcPol.getCoeff(x_exp, deg-x_exp).getEpsPrecision() );

                        for (int prec=0; prec<= MaxEpsPrecision ; prec++)
                        {
                                destPol.getCoeffRef(    x_exp, deg-x_exp).setValue(prec, 0);
                        }

                        
                        for (int prec=0; prec<= MaxEpsPrecision ; prec++)
                        {
                                destPol.getCoeffRef(    x_exp, deg-x_exp).setValue(prec,
                                                                                        srcPol.getCoeff(x_exp, deg-x_exp).getValue(prec) );
                        }
                }
        }
}



template<class TPolynomXY, class TRing>
template <class TPolynomXY_Type>
void    PolynomialRing<TPolynomXY, TRing>::convertInPlace( TPolynomXY_Type  & pol ) const
{
        for (int deg = pol.getDegree(); deg>=0; deg--)
        {
                for (int x_exp=deg; x_exp>=0; x_exp--)
                {
                        int MaxEpsPrecision= (int)pol.getCoeff(x_exp, deg-x_exp).getEpsPrecision();
                        for (int prec=0; prec<= MaxEpsPrecision ; prec++)
                        {
                                pol.getCoeffRef(        x_exp, deg-x_exp).setValue(prec,
                                                                                        ring_ref_m.ConvertScalar(pol.getCoeff(x_exp, deg-x_exp).getValue(prec)) );
                        }
                }
        }
}