polynom.h

Go to the documentation of this file.

#ifndef POLYNOM_H4D45E74F99FC
#define POLYNOM_H4D45E74F99FC

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000


#include <fstream>
#include <iostream>
#include <assert.h>

#include <stdlib.h>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>



//using namespace std;
using  std::cout;
using  std::cerr;
using  std::endl;
using  std::string;
using  std::vector;
using  std::ostream;
using  std::stringstream;

#include "parseTools.h"

template <class PolynomXY_Type, class RingType, class _istream>
PolynomXY_Type  createFromStream (_istream & _polynomStream, RingType & ringRef )
{

        
//      std::cerr << "_polynomStream: "<<  _polynomStream.str() << std::endl;

        std::string             polynomStr = extractNextBracedData( _polynomStream );

        std::stringstream       polynomStream( polynomStr);

        int                             mononGroupNum = countSubGroups( polynomStream );

        //std::cerr << "momonroups: "<<  mononGroupNum << std::endl;

        
        int     MaxMonomDegree = getMaxMonomDegree( polynomStr );
        vector<int> degreeTracking(MaxMonomDegree + 1);
        
        PolynomXY_Type res(MaxMonomDegree);
        
        
        polynomStream.clear();
        polynomStream.seekg(0);
        
        extractChar(polynomStream, '{');
        //std::cerr << "matrixStream" << matrixStream.str() << std::endl;

        for ( int currMonomGroupNum = 1;  currMonomGroupNum <= mononGroupNum ;  currMonomGroupNum ++ )
        {
                std::string  monomGroup   = extractNextBracedData(polynomStream);
                std::stringstream ssMonomGroup(monomGroup);

                int currDegree = countElements(ssMonomGroup) -1;
                //std::cerr << "currDegree" << currDegree << std::endl; 
                ssMonomGroup.clear();
                ssMonomGroup.seekg(0);
                //safety:
                assert(degreeTracking[currDegree] == 0);
                degreeTracking[currDegree]  = 1 ;

                //std::cerr << "monomGroup" << monomGroup << std::endl; 
                        
                extractChar(ssMonomGroup, '{');

                for ( int y_exp=0;  y_exp <= currDegree ;  y_exp++)
                {
                        // extract next unbraced Element on current brace Level (finished by ',' or '}')
                        string nextElement=extractNextData(ssMonomGroup);

                //      std::cerr << "nextElement" << nextElement << std::endl; 

                        typename PolynomXY_Type::CoefficientType  coeff = parseNumber( &ringRef, nextElement.c_str(), ringRef.getEpsPrecision() );
                
                        res.setCoeff( currDegree - y_exp, y_exp, coeff );

                        if (y_exp !=currDegree ) 
                                extractChar( ssMonomGroup, ',' );
                        else extractChar( ssMonomGroup, '}' );
                }
                if (currMonomGroupNum !=mononGroupNum ) 
                                extractChar( polynomStream, ',' );
                else extractChar( polynomStream, '}' );
        }
        //std::cerr << "polynom initialization OK" << std::endl;
        return res;
}

template <class PolynomXY_Type, class RingType>
PolynomXY_Type  createFromString (string & _polynomString, RingType & ringRef )
{
        stringstream strstream   (   _polynomString);
        return createFromStream<PolynomXY_Type>( strstream, ringRef);
}

template <class TNum, class TIndex>
class polynomXY  
{
private:
         short  maxDegree; 
         short  maxDegreePlusOne;
        TIndex   idefs;
         short  size;   
        TNum *  koeff;  

        //TNum * *      offsets;
        string  name;   
        

public:

        typedef TNum    CoefficientType;

                polynomXY();
                polynomXY(const short _maxDegree);
        
                polynomXY(string _name, const short _maxDegree);
        
                polynomXY(const polynomXY&);

                ~polynomXY();
                inline void     setDegree(short maxDegree);

                inline void     clear(short maxDegree);
                inline void     clear();
                inline void             setCoeff(const short x_exp,const short y_exp, const TNum value);
        
                inline TNum             getCoeff(const short x_exp,const short y_exp)   const;
        
                inline TNum const       getCoeffConst(const short x_exp,const short y_exp) const;
        
                inline const TNum &     getCoeffConstRef(const int x_exp,const int y_exp) const;
        
                inline TNum&            getCoeffRef(const short x_exp, const short y_exp);

                inline TNum const *     getCoeffConstAddr(const short x_exp, const short y_exp) const;
                inline TNum *           getCoeffAddr(const short x_exp, const short y_exp);
                inline  short   getDegree() const;
                
                inline string   getName() const {       return name;    };

                inline short    getMaxDegree() const;
                inline void testBounds(const short x_exp, const short y_exp) const;

                polynomXY& operator=(const polynomXY&);
                bool operator==(const polynomXY&) const;
        //void update(std::string s);
        //void update(std::string s);

                void OutputPureCoefficients( ostream &datei, int maxDegree, bool mitKomma) const;
                void output( std::ostream& os) const;
                void printInMacaulayStyle( std::ostream& os) const;
                void outputMatrix() const;
                void print( std::ostream& os) const;
        private:
                inline int  getIndex(const short x_exp, const short y_exp) const;

};





template <class TNum>
class polynomx
{
        private:
                 int    maxDegree;
                 int    size;
                TNum *          koeff; 

        protected:
                        inline void             testbounds(const int x_exp) const;
        public:
        
                typedef TNum    CoefficientType;

                        polynomx(const int gr);
                        inline  polynomx(const polynomx & fpx);

                        virtual ~polynomx();

                        inline polynomx & operator=(const polynomx & fpx);

        
                        void    clear(int _degree);
                        void    clear();
                        inline TNum             getCoeff(const int x_exp)  const;
                
                        inline  TNum&           getCoeffRef(const int x_exp) ;

                        inline  const TNum&     getCoeffConstRef(const int x_exp) const;

                        inline  TNum const      getCoeffConst(const int x_exp)  const;
                
                        inline void             setCoeff(const int x_exp, const TNum& value);
        
                        inline const int        getDegree() const ;
};



template <typename TNum, typename TIndex>
std::ostream &  operator<<(std::ostream & out, const polynomXY<TNum, TIndex>& z)  
{       
        z.print(out);
        return out;
}





#include "polynom.cpp"

#endif // ifndef POLYNOM_H4D45E74F99FC