00001
00002
00003
00004
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
00100
00101
00102
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
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
00153
00154
00155
00156 for (short dim=0; dim<defs::size_m ; dim++)
00157 koeff[dim] = fpx.koeff[dim];
00158
00159 }
00160
00161
00162
00163
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
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
00216
00217
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
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
00267
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
00281
00282
00283
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
00372 return (maxDegree);
00373 };
00374
00375
00376 template <class defs,class TNum>
00377 inline short fast_polynomXY<defs,TNum>::getMaxDegree() const
00378 {
00379
00380 return (maxDegree);
00381 };
00382
00383 template <class defs,class TNum>
00384 inline void fast_polynomXY<defs,TNum>::setDegree(int degree) const
00385 {
00386
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
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418
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
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
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
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