fast_polynom.cpp

Go to the documentation of this file.
00001 
00002 
00003 
00004 //------------------------------------polynomXY---------------------------------------------------
00005 
00006 template <class defs,class TNum>
00007 fast_polynomXY< defs, TNum>::fast_polynomXY(short _degree):             maxDegree(_degree),
00008                                                                                         maxDegreePlusOne(_degree+1),
00009                                                                                         koeff( new TNum[defs::size_m] )
00010 {
00011         #ifdef CF_TEST
00012                 name="";
00013         #endif
00014         if  ( ! (defs::maxdegree_m>=maxDegree && maxDegree >=0) )
00015         {
00016                 std::cerr << " please set the compile parameter MAXMONOMDEGREE to " << maxDegree << std::endl;
00017         }
00018         assert(defs::maxdegree_m>=maxDegree && maxDegree >=0);
00019 
00020 
00021         if ( TNum::memsetClearAllowed() )
00022                 memset(koeff ,0x00,defs::size_m*sizeof(TNum));
00023         else
00024                 for (short dim=defs::size_m-1; dim>=0; dim--)
00025                         koeff[dim] = TNum::Zero;
00026         
00027 
00028         #ifdef COUNT
00029         memAccess += defs::size_m;
00030         #endif 
00031 }
00032 
00033 template <class defs,class TNum>
00034 fast_polynomXY< defs, TNum>::fast_polynomXY():  maxDegree(defs::maxdegree_m), 
00035                                                                 maxDegreePlusOne(defs::maxdegree_m+1),
00036                                                                 koeff( new TNum[defs::size_m] )
00037 {
00038         #ifdef CF_TEST
00039                 name="";
00040         #endif
00041         
00042         assert(defs::maxdegree_m>=maxDegree && maxDegree >=0);
00043 
00044 
00045         if ( TNum::memsetClearAllowed() )
00046                 memset(koeff ,0x00,defs::size_m*sizeof(TNum));
00047         else
00048                 for (short dim=defs::size_m-1; dim>=0; dim--)
00049                         koeff[dim] = TNum::Zero;
00050         
00051 
00052         #ifdef COUNT
00053         memAccess += defs::size_m;
00054         #endif 
00055 }
00056 
00057 template <class defs,class TNum>
00058 fast_polynomXY< defs, TNum>::fast_polynomXY(string _name, short _degree):       maxDegree(_degree),
00059                                                                                                         maxDegreePlusOne(_degree+1),
00060                                                                                                         koeff( new TNum[defs::size_m] )
00061 {
00062         #ifdef CF_TEST
00063                 name=_name;
00064         #endif
00065                 
00066         assert(defs::maxdegree_m>=maxDegree && maxDegree >=0);
00067         
00068         if ( TNum::memsetClearAllowed() )
00069                 memset(koeff ,0x00,defs::size_m*sizeof(TNum));
00070                                 
00071         else
00072                 for (short dim=defs::size_m-1; dim>=0; dim--)
00073                         koeff[dim] = TNum::Zero;
00074         
00075 
00076         #ifdef COUNT
00077         memAccess += defs::size_m;
00078         #endif 
00079 }
00080 
00081  
00082 template <>
00083 inline
00084 fast_polynomXY< polynomdefsNew<FIELDCHAR>, short int >
00085 		::fast_polynomXY(string _name, short _degree):        maxDegree(_degree),
00086                                                                                 maxDegreePlusOne(_degree+1),
00087                                                                                 koeff( new short[polynomdefsNew<FIELDCHAR>::size_m] )
00088 {
00089         #ifdef CF_TEST
00090                 name=_name;
00091         #endif
00092                 
00093         if  ( ! (polynomdefsNew<FIELDCHAR>::maxdegree_m>=maxDegree && maxDegree >=0) )
00094         {
00095                 std::cerr << " please set the compile parameter MAXMONOMDEGREE to " << maxDegree << std::endl;
00096         }
00097         assert(polynomdefsNew<FIELDCHAR>::maxdegree_m>=maxDegree && maxDegree >=0);
00098         
00099         //if ( TNum::memsetClearAllowed() )
00100         //      memset(koeff ,0x00,defs::size_m*sizeof(short));
00101                                 
00102         //else
00103                 for (short dim=polynomdefsNew<FIELDCHAR>::size_m-1; dim>=0; dim--)
00104                         koeff[dim] = 0;
00105         
00106         
00107         #ifdef COUNT
00108         memAccess += polynomdefsNew<FIELDCHAR>::size_m;
00109         #endif 
00110 }
00111 
00112 
00113 
00114 template <class defs,class TNum>
00115 fast_polynomXY< defs, TNum>::~fast_polynomXY()
00116 {
00117         delete[] koeff;
00118 }
00119 
00120 
00121 template <class defs,class TNum>
00122 inline fast_polynomXY<defs, TNum>::fast_polynomXY(const fast_polynomXY<defs, TNum >& fpx): maxDegree(fpx.maxDegree),
00123                                                                                                                         maxDegreePlusOne(fpx.maxDegreePlusOne),
00124                                                                                                                         koeff( new TNum[defs::size_m] )
00125 {
00126 
00127         assert(defs::maxdegree_m>=maxDegree && maxDegree >=0);
00128         //assert(defs::maxdegree_m==maxDegree);
00129 
00130         if (maxDegree!=fpx.maxDegree)
00131         {
00132 
00133                 maxDegree=fpx.maxDegree;
00134                 #ifdef DEBUG
00135                         std::cerr << "maxDegree" << maxDegree << std::endl;
00136                         std::cerr << "fpx.maxDegree" << fpx.maxDegree << std::endl;  
00137                 #endif
00138 
00139                 if ( TNum::memsetClearAllowed() )
00140                         memset(koeff ,0x00,defs::size_m*sizeof(TNum));
00141                 else
00142                         for (short dim=defs::size_m-1; dim>=0; dim--)
00143                                 koeff[dim] = TNum::Zero;
00144 
00145                 for (short i=0; i<=fpx.maxDegree; i++)
00146                         for(short j=0; j<=i; j++)
00147                                         getCoeff( i-j, j) = fpx.getCoeff( i-j, j);
00148         }
00149         else
00150         {
00151 
00152                 //maxDegreePlusOne = maxDegree+1;
00153 
00154                 //koeff = new TNum[defs::size_m];
00155 
00156                 for (short dim=0; dim<defs::size_m ; dim++)
00157                         koeff[dim] = fpx.koeff[dim];
00158 
00159         }
00160 
00161 
00162 //      for (short dim=defs::size_m-1; dim>=0; dim--)
00163 //              koeff[dim] = fpx.koeff[dim];
00164 }
00165 
00166 
00167 template <class defs,class TNum>
00168 inline bool fast_polynomXY< defs, TNum>::operator==(const fast_polynomXY<defs, TNum>& fpx) const
00169 {
00170          
00171         assert(&fpx!=NULL);
00172 
00173         for (short i=0; i<=maxDegree; i++)
00174                 for(short j=0; j<=i; j++)
00175                         if (  getCoeff( i-j, j) != fpx.getCoeff( i-j, j) )
00176                                 return false;
00177 
00178         return true;
00179 }
00180 
00181 
00182 
00183 template <class defs,class TNum>
00184 inline fast_polynomXY< defs, TNum>& fast_polynomXY< defs, TNum>::operator=(const fast_polynomXY<defs, TNum>& fpx)
00185 {
00186         if (this!=&fpx)
00187         {
00188                 assert(&fpx!=NULL);
00189                 
00190                 assert(defs::maxdegree_m>=fpx.maxDegree && fpx.maxDegree >=0);
00191         
00192                 //assert(maxDegree       == fpx.maxDegree);
00193 
00194                 if (maxDegree!=fpx.maxDegree)
00195                 {
00196                         maxDegree=fpx.maxDegree;
00197                         #ifdef DEBUG
00198                                 std::cerr << "maxDegree" << maxDegree << std::endl;
00199                                 std::cerr << "fpx.maxDegree" << fpx.maxDegree << std::endl;  
00200                         #endif
00201 
00202                         if ( TNum::memsetClearAllowed() )
00203                                 memset(koeff ,0x00,defs::size_m*sizeof(TNum));
00204                         else
00205                                 for (short dim=defs::size_m-1; dim>=0; dim--)
00206                                         koeff[dim] = TNum::Zero;
00207 
00208                         for (short i=0; i<=fpx.maxDegree; i++)
00209                                 for(short j=0; j<=i; j++)
00210                                          getCoeff( i-j, j) = fpx.getCoeff( i-j, j);
00211                 }
00212                 else
00213                 {
00214         
00215                         //maxDegreePlusOne = maxDegree+1;
00216         
00217                         //koeff = new TNum[defs::size_m];
00218         
00219                         for (short dim=0; dim<defs::size_m ; dim++)
00220                                 koeff[dim] = fpx.koeff[dim];
00221 
00222                 }
00223         }
00224         return *this;
00225 }
00226 //------------------------------------polynomXY safety---------------------------------------------------
00227 
00228 #ifdef SAFE
00229 template <class defs,class TNum>
00230 inline void fast_polynomXY<defs,TNum>::testbounds(const short x_exp,const short y_exp) const
00231         {       
00232                 assert(x_exp + y_exp<=maxDegree);
00233                 assert(x_exp>=0 && y_exp>=0);
00234         }
00235 
00236 #endif
00237 
00238 template <class defs,class TNum>
00239 inline void fast_polynomXY<defs,TNum>::setCoeffFromRef(const short x_exp,const short y_exp, const TNum& value)
00240         {
00241                 #ifdef SAFE
00242                         testbounds(x_exp,y_exp);
00243                 #endif
00244         
00245                 koeff[defs::getPairIndex(x_exp,y_exp)] = value;
00246 
00247                 #ifdef COUNT    
00248                         memAccess+=1;
00249                 #endif
00250         };
00251 
00252 template <class defs,class TNum>
00253 inline void fast_polynomXY<defs,TNum>::setCoeff(const short x_exp,const short y_exp, const TNum value)
00254         {
00255                 #ifdef SAFE
00256                         testbounds(x_exp,y_exp);
00257                 #endif
00258         
00259                 koeff[defs::getPairIndex(x_exp,y_exp)] = value;
00260 
00261                 #ifdef COUNT    
00262                         memAccess+=1;
00263                 #endif
00264         };
00265 
00266 // sollte nicht nur getKoeff liefern, sondern auch 
00267 // auch getREf, oder?
00268 template <class defs,class TNum>
00269 inline  TNum fast_polynomXY<defs,TNum>::getCoeff(const short x_exp,const short y_exp) const
00270 {
00271         #ifdef SAFE
00272                 testbounds(x_exp,y_exp);
00273                 assert(defs::size_m>defs::getPairIndex(x_exp,y_exp));
00274         #endif
00275 
00276         #ifdef COUNT    
00277                 memRef+=1;
00278         #endif
00279         #ifdef DEBUG
00280         //      assert(defs::size_m<defs::getPairIndex(x_exp,y_exp));
00281         //      std::cerr << "defs::size_m" << defs::size_m << std::endl;
00282         //      std::cerr << "defs::getPairIndex(x_exp,y_exp)"  << defs::getPairIndex(x_exp,y_exp) << std::endl;
00283         //      std::cerr << "(x_exp,y_exp) = ("  << x_exp  <<"," << y_exp << ")" << std::endl;
00284                 assert(defs::size_m>defs::getPairIndex(x_exp,y_exp));
00285                 
00286         #endif
00287         return (koeff[defs::getPairIndex(x_exp,y_exp)]);
00288 }
00289 
00290 
00291 
00292 template <class defs,class TNum>
00293 inline TNum const fast_polynomXY<defs,TNum>::getCoeffConst(const short x_exp,const short y_exp) const
00294 {
00295         #ifdef SAFE
00296                 testbounds(x_exp,y_exp);
00297         #endif
00298 
00299         #ifdef COUNT    
00300                 memAccess+=1;
00301         #endif
00302 
00303         return (koeff[defs::getPairIndex(x_exp,y_exp)]);
00304 }
00305 
00306 
00307 template <class defs,class TNum>
00308 inline const TNum& fast_polynomXY<defs,TNum>::getCoeffConstRef(const short  x_exp,const short y_exp) const
00309 {
00310         #ifdef SAFE
00311                 testbounds(x_exp,y_exp);
00312         #endif
00313 
00314         #ifdef COUNT    
00315                 memRef+=1;
00316         #endif
00317 
00318         return (koeff[defs::getPairIndex(x_exp,y_exp)]);
00319 }
00320 
00321 
00322 template <class defs,class TNum>
00323 inline TNum& fast_polynomXY<defs,TNum>::getCoeffRef(const short x_exp,const short y_exp) 
00324 {
00325         #ifdef SAFE
00326                 testbounds(x_exp,y_exp);
00327         #endif
00328 
00329         #ifdef COUNT    
00330                 memRef+=1;
00331         #endif
00332 
00333         return (koeff[defs::getPairIndex(x_exp,y_exp)]);
00334 }
00335 
00336 
00337 template <class defs,class TNum>
00338 inline TNum const * fast_polynomXY<defs,TNum>::getCoeffConstAddr(const short x_exp,const short y_exp) const
00339 {
00340         #ifdef SAFE
00341                 testbounds(x_exp,y_exp);
00342         #endif
00343 
00344         #ifdef COUNT    
00345                 memRef+=1;
00346         #endif
00347 
00348         return &(koeff[defs::getPairIndex(x_exp,y_exp)]);
00349 }
00350 
00351 
00352 template <class defs,class TNum>
00353 inline TNum* fast_polynomXY<defs,TNum>::getCoeffAddr(const short x_exp,const short y_exp)
00354 {
00355         #ifdef SAFE
00356                 testbounds(x_exp,y_exp);
00357         #endif
00358 
00359         #ifdef COUNT    
00360                 memRef+=1;
00361         #endif
00362 
00363         return &(koeff[ defs::getPairIndex(x_exp, y_exp) ]);
00364 }
00365 
00366 
00367 
00368 template <class defs,class TNum>
00369 inline  short fast_polynomXY<defs,TNum>::getDegree() const
00370 {
00371         //memAccess???
00372         return (maxDegree);
00373 };
00374 
00375 
00376 template <class defs,class TNum>
00377 inline  short fast_polynomXY<defs,TNum>::getMaxDegree() const
00378 {
00379         //memAccess???
00380         return (maxDegree);
00381 };
00382 
00383 template <class defs,class TNum>
00384 inline void fast_polynomXY<defs,TNum>::setDegree(int degree) const
00385 {
00386         //memAccess???
00387         assert(maxDegree==degree);
00388 };
00389 
00390 
00395 template <class defs,class TNum>
00396 inline void fast_polynomXY<defs,TNum>::clear(short _degree)
00397 {
00398 /*
00399         TNum* addr1 = &koeff[ defs::getPairIndex(_degree,0) ];
00400         TNum* addr2 = &koeff[ defs::getPairIndex(0,_degree) ];
00401         
00402 
00403         if (addr2>addr1)
00404                 addr1=addr2;
00405 
00406         if (  TNum::memsetClearAllowed()  )
00407         {
00408                 // ein test hat ergeben , , dass die  (addr1-koeff) beruecksichtigt, dass es sich um, Zeiger auf TNum handelt.
00409                 // es wird also nicht die Adresse abgezogen ,sondern die Anzahl der Felder
00410                 memset(koeff ,0x00,   sizeof(TNum)*(addr1-koeff+1) );
00411         }
00412         else
00413         {
00414                 int lastPos = (addr1-koeff)/sizeof(TNum);
00415                 //cerr << "lastPos()" << lastPos << endl;
00416 
00417                 for (int dim=0; dim< lastPos ; dim++)
00418                         koeff[dim] = TNum::Zero;
00419                 
00420         }
00421 */      
00422         for (register short i=0; i<= _degree; ++i)
00423                 for(register short j=0; j<=i; ++j)
00424                 {
00425                         koeff[defs::getPairIndex(i-j,j)] = TNum::Zero;
00426                         #ifdef COUNT
00427                                 memAccess+=1;
00428                         #endif 
00429                 }
00430         
00431         #ifdef SAFE
00432                 for (register short i=0; i<= _degree; ++i)
00433                         for(register short j=0; j<=i; ++j)
00434                         {
00435                                 if (koeff[defs::getPairIndex(i-j,j)] != TNum::Zero )
00436                                 {
00437                                         cerr << "koeff[defs::getPairIndex(i-j,j)]  "<<  koeff[defs::getPairIndex(i-j,j)]  << endl;
00438                                         cerr << "koeff[defs::getPairIndex(i-j,j)] - koeff"<< &koeff[defs::getPairIndex(i-j,j)] - koeff << endl;
00439                                 }
00440                                 assert (koeff[defs::getPairIndex(i-j,j)] == TNum::Zero );
00441                                 #ifdef COUNT
00442                                         memAccess+=1;
00443                                 #endif 
00444                         }
00445         #endif
00446 }
00447 
00448 
00449 template < >
00450 inline void fast_polynomXY<polynomdefsNew<FIELDCHAR >, short>::clear(short _degree)
00451 { 
00452         for (register short i=0; i<= _degree; ++i)
00453                 for(register short j=0; j<=i; ++j)
00454                 {
00455                         koeff[polynomdefsNew<FIELDCHAR >::getPairIndex(i-j,j)] = 0;
00456                         #ifdef COUNT
00457                                 memAccess+=1;
00458                         #endif 
00459                 }
00460         
00461         #ifdef SAFE
00462                 for (register short i=0; i<= _degree; ++i)
00463                         for(register short j=0; j<=i; ++j)
00464                         {
00465                                 if (koeff[polynomdefsNew<FIELDCHAR >::getPairIndex(i-j,j)] != 0)
00466                                 {
00467                                         cerr << "koeff[defs::getPairIndex(i-j,j)]  "<<  koeff[polynomdefsNew<FIELDCHAR >::getPairIndex(i-j,j)]  << endl;
00468                                         cerr << "koeff[defs::getPairIndex(i-j,j)] - koeff"<< &koeff[polynomdefsNew<FIELDCHAR >::getPairIndex(i-j,j)] - koeff << endl;
00469                                 }
00470                                 assert (koeff[polynomdefsNew<FIELDCHAR >::getPairIndex(i-j,j)] == 0 );
00471                                 #ifdef COUNT
00472                                         memAccess+=1;
00473                                 #endif 
00474                         }
00475         #endif
00476 }
00477 
00478 
00480 template <class defs,class TNum>
00481 inline void fast_polynomXY<defs,TNum>::clear()
00482 {
00483 
00484         if (  TNum::memsetClearAllowed()  )
00485                 memset(koeff ,0x00, defs::size_m*sizeof(TNum));
00486         else
00487                 for (int dim=0; dim<defs::size_m ; dim++)
00488                         koeff[dim] = TNum::Zero;
00489 
00490         #ifdef COUNT
00491                 memAccess += defs::size_m;
00492         #endif 
00493 }
00494  
00495 
00496 
00497 
00498 
00499 template <class defs,class TNum>
00500 void fast_polynomXY<defs,TNum>::output(ostream & os) const
00501 {
00502         for (int i=0; i<=maxDegree; i++)
00503                 for(int j=0; j<=i; j++)
00504                 {
00505                         TNum z=getCoeff(i-j, j); 
00506                         if ( z.isNotZero() )
00507                                 os << "(" << z << ")*" << "x^" << i-j << "y^" << j << " + ";
00508                 }
00509 }
00510 
00511 
00512 template <class defs,class TNum>
00513 void fast_polynomXY<defs,TNum>::outputMatrix(ostream &os) const
00514 {
00515         os << std::endl;
00516 
00517         #ifdef CF_TEST
00518                 //os <<"Name: " << name  ;
00519         #endif
00520 
00521         for (int i=0; i<=maxDegree; i++)
00522         {
00523                 os << "i" << i << " ";
00524                 for(int j=0; j<=i; j++)
00525                 {
00526                         TNum    z = getCoeff(i-j, j); 
00527                         if ( z.isNotZero() )
00528                                 os << "(" << z <<")*" << "x^" << i-j << "y^" << j << " + ";
00529                 }
00530                 os << std::endl;
00531         }
00532 }
00533 
00534 
00535 
00536 
00538 template <class defs,class TNum>
00539 void fast_polynomXY<defs,TNum>::OutputPureCoefficients(ostream &ofile, int maxDegree, bool mitKomma) const
00540 {
00541         ofile << "{";
00542         for(int j=0; j<=maxDegree; j++)
00543                 {
00544                         TNum    z = getCoeff(maxDegree-j, j); 
00545                         ofile <<  z << " " ;
00546                         if ( j<maxDegree )
00547                                 ofile << ", ";
00548                 }
00549 
00550         ofile << "} ";
00551 
00552         if (mitKomma==true) (ofile) << ", ";
00553 
00554 
00555         //macaulay comment:
00556         ofile << "      -- ";
00557         
00558         for(int j=0; j<=maxDegree; j++)
00559         {
00560                 TNum    z =getCoeff(maxDegree-j, j); 
00561                 ofile << "(" << z<< ")*x^" << maxDegree-j << "y^" << j;
00562                 if (j<maxDegree)
00563                         ofile << " + ";
00564         }
00565 
00566 
00567         ofile << std::endl;
00568 }
00569 
00570 
00571 
00572 
00573 
00574 
00575 
00576 
00577 
00578 
00579 
00580 
00581 
00582 
00583 
00584 
00585 
00586 
00587 
00588 
00589 
00590 
00591 //------------------------------------polynomx---------------------------------------------------
00592 
00593         template <class TNum>
00594         fast_polynomx<TNum>::fast_polynomx(const int gr): maxDegree(gr), size(gr+1)
00595         {
00596 
00597                 koeff = new TNum[size] ;
00598                 clear();
00599                 #ifdef SAFE
00600                         for (int dim=0; dim<size ; dim++)
00601                                 koeff[dim] = TNum::Zero;
00602                 #endif
00603         }
00604 
00605 
00606 
00607 
00608         template <class TNum>
00609         fast_polynomx<TNum>::~fast_polynomx()
00610         {
00611                 delete[] koeff;
00612         }
00613 
00614         template <class TNum>
00615         inline fast_polynomx<TNum>::fast_polynomx(const fast_polynomx& fpx):maxDegree(fpx.maxDegree),size(fpx.size)
00616         {
00617                 koeff = new TNum[size];
00618                 for (int dim=0; dim<size ; dim++)
00619                         koeff[dim] = fpx.koeff[dim];
00620         }
00621 
00622 
00623         template <class TNum>
00624         inline fast_polynomx<TNum>& fast_polynomx<TNum>::operator=(const fast_polynomx<TNum>& fpx)
00625         {
00626                 if (this!=&fpx)
00627                 {
00628                         assert(&fpx!=NULL);
00629                         assert(maxDegree==fpx.maxDegree);
00630                         assert(size==fpx.size);
00631                         delete koeff;
00632 
00633                         koeff = new TNum[size];
00634                         for (int dim=0; dim<size ; dim++)
00635                                 koeff[dim] = fpx.koeff[dim];
00636                 }
00637                 return *this;
00638         }
00639         
00640         template <class TNum>
00641         inline TNum fast_polynomx<TNum>::getCoeff(const int x_exp)  const
00642         {
00643                 #ifdef SAFE
00644                         testbounds(x_exp);
00645                 #endif
00646 
00647                 #ifdef COUNT
00648                         memAccess+=1;
00649                 #endif 
00650                 return (koeff[x_exp]);
00651         }
00652 
00653 
00654         template <class TNum>
00655         inline TNum& fast_polynomx<TNum>::getCoeffRef(const int x_exp)  
00656         {       
00657                 #ifdef SAFE
00658                         testbounds(x_exp);
00659                 #endif
00660 
00661                 #ifdef COUNT
00662                         memRef+=1;
00663                 #endif 
00664 
00665                 return (koeff[x_exp]);
00666         }
00667 
00668 
00669         template <class TNum>
00670         inline const TNum& fast_polynomx<TNum>::getCoeffConstRef(const int x_exp)  const
00671         {       
00672                 #ifdef SAFE
00673                         testbounds(x_exp);
00674                 #endif
00675 
00676                 #ifdef COUNT
00677                         memRef+=1;
00678                 #endif 
00679 
00680                 return (koeff[x_exp]);
00681         }
00682 
00683 
00684         template <class TNum>
00685         inline  TNum const fast_polynomx<TNum>::getCoeffConst(const int x_exp)  const
00686         {       
00687                 #ifdef SAFE
00688                         testbounds(x_exp);
00689                 #endif
00690 
00691                 #ifdef COUNT
00692                         memAccess+=1;
00693                 #endif 
00694                 return (koeff[x_exp]);
00695         }
00696 
00697 
00698         template <class TNum>
00699         inline void fast_polynomx<TNum>::setCoeff(const int x_exp, const TNum& value)
00700         {
00701                 #ifdef SAFE
00702                         testbounds(x_exp);
00703                 #endif
00704 
00705                 #ifdef COUNT
00706                         memAccess+=1;
00707                 #endif 
00708 
00709                 koeff[x_exp] = value;
00710         }
00711         
00713         template <class TNum>
00714         inline void fast_polynomx<TNum>::clear(int _degree)
00715         {
00716 
00717                 #ifdef DEBUG
00718                         assert(_degree<=maxDegree);
00719                         assert(size<=_degree);
00720                 #endif
00721                 if (_degree>maxDegree)
00722                         _degree=maxDegree;
00723                 
00724                 if ( TNum::memsetClearAllowed() )
00725                         memset(koeff ,0x00,(_degree+1)*sizeof(TNum));
00726 
00727                 else    
00728                         for (register int dim=0; (dim<size && dim<=_degree); dim++)
00729                                 koeff[dim]=TNum::Zero;
00730 
00731                 
00732                 #ifdef COUNT
00733                         memAccess+=_degree;
00734                 #endif 
00735 
00736         }
00737 
00738 
00739         template <class TNum>
00740         inline void fast_polynomx<TNum>::clear()
00741         {
00742                 #ifdef COUNT
00743                         memAccess+=size;
00744                 #endif 
00745 
00746 
00747                 if ( TNum::memsetClearAllowed() )
00748                         memset(koeff ,0x00,size*sizeof(TNum));
00749 
00750                 else    for (int dim=0; dim< this->size ; dim++)
00751                                 assert(koeff[dim]==TNum::Zero);
00752         }
00753 
00754         
00755         template <class TNum>
00756         inline const int fast_polynomx<TNum>::getDegree() const 
00757         {
00758                 return(maxDegree);
00759         };
00760 
00761 
00762         
00763         
00764         
00765         
00766                 
00767         
00768         #ifdef SAFE
00769                 template <class TNum>
00770                 inline void fast_polynomx<TNum>::testbounds(const int x_exp) const
00771                 {
00772                         if (x_exp<0 || x_exp >= maxDegree+1 )
00773                         {
00774                                         std::cerr << " polynomx::getCoeff(): Err";
00775                                         std::cerr << " x_exp =" << x_exp;
00776                                         std::cerr << " maxDegree+1= " << maxDegree+1;
00777                                         std::cerr << fflush;
00778                         }
00779                         assert( x_exp<=maxDegree);
00780                         assert( x_exp>=0);
00781                 }
00782         #endif
00783         
00784         
00785         #ifdef DEBUG
00786         template <class TNum>
00787         void fast_polynomx<TNum>::output(std::ostream& os) const
00788         {
00789                 os << "a: " << std::endl;
00790                 for (int i=0; i<=maxDegree; i++)
00791                 {
00792                         TNum    z = getCoeff(i); 
00793                         os << "(" << z <<")" << "x^" << i << " + ";
00794                 }
00795         }
00796         #endif
00797 
Generated on Tue Nov 23 13:10:51 2010 for centerfocus by  doxygen 1.6.3