|
realroot_doc 0.1.1
|
|
realroot_doc 0.1.1
|
00001 /********************************************************************* 00002 * This file is part of the source code of realroot package. * 00003 * (C) B. Mourrain, GALAAD, INRIA * 00004 ********************************************************************** 00005 History: Initialized from the Posso file. 00006 Modified in order to handel different internal representation. 00007 **********************************************************************/ 00008 #ifndef NDEBUG 00009 #include <assert.h> 00010 #endif // 00011 #ifndef realroot_scalar_hpp 00012 #define realroot_scalar_hpp 00013 00014 //---------------------------------------------------------------------- 00015 #include <stdio.h> 00016 #include <realroot/shared_object.hpp> 00017 //---------------------------------------------------------------------- 00018 #define WITH_REFCOUNT 00019 namespace mmx { 00020 namespace let {template<class A, class B> inline void assign(A& a, const B& b); } 00024 template<class T> struct scalar 00025 { 00026 public: 00027 //data 00028 #ifdef WITH_REFCOUNT 00029 shared_object<T> data; 00030 T & rep() {return (*data);} 00031 const T & rep() const {return (*data);} 00032 #else 00033 T data; 00034 inline T & rep() {return (data);} 00035 inline const T & rep() const {return (data);} 00036 #endif 00037 scalar (){this->init();}; 00038 scalar (const scalar<T>& b); //{ data=b.data;} 00039 template<class R> inline 00040 scalar (const scalar<R>& x) { this->init(); let::assign(*this,x); } 00041 scalar (double d){this->init(); 00042 let::assign(*this,d); 00043 //data=T(d); 00044 }; 00045 scalar (signed long sl); 00046 scalar (unsigned long ul); 00047 scalar (int si); 00048 scalar (unsigned x){this->init(); let::assign(*this,x);}; 00049 scalar (const char* string, unsigned int b=10); 00050 00051 ~scalar () {} 00052 00053 bool operator == (const scalar<T>& rhs) const; 00054 bool operator != (const scalar<T>& rhs) const; 00055 bool operator > (const scalar<T>& rhs) const; 00056 bool operator >= (const scalar<T>& rhs) const; 00057 bool operator < (const scalar<T>& rhs) const; 00058 bool operator <= (const scalar<T>& rhs) const; 00059 00060 bool operator == (long sl) const; 00061 bool operator != (long sl) const; 00062 bool operator > (long sl) const; 00063 bool operator >= (long sl) const; 00064 bool operator < (long sl) const; 00065 bool operator <= (long sl) const; 00066 00067 bool operator == (int si) const; 00068 bool operator != (int si) const; 00069 bool operator > (int si) const; 00070 bool operator >= (int si) const; 00071 bool operator < (int si) const; 00072 bool operator <= (int si) const; 00073 00074 bool operator == (unsigned long ul) const; 00075 bool operator != (unsigned long ul) const; 00076 bool operator > (unsigned long ul) const; 00077 bool operator >= (unsigned long ul) const; 00078 bool operator < (unsigned long ul) const; 00079 bool operator <= (unsigned long ul) const; 00080 00081 // functions that modify at least one argument or `*this' 00082 scalar<T>& operator = (const scalar<T>& rhs);// {data=rhs.data; return *this;} 00083 scalar<T>& operator += (const scalar<T>& rhs); 00084 scalar<T>& operator -= (const scalar<T>& rhs); 00085 scalar<T>& operator *= (const scalar<T>& rhs); 00086 scalar<T>& operator /= (const scalar<T>& rhs); 00087 scalar<T>& operator %= (const scalar<T>& rhs); 00088 00089 scalar<T>& operator = (unsigned rhs); 00090 scalar<T>& operator += (unsigned rhs); 00091 scalar<T>& operator -= (unsigned rhs); 00092 scalar<T>& operator *= (unsigned rhs); 00093 scalar<T>& operator /= (unsigned rhs); 00094 scalar<T>& operator %= (unsigned rhs); 00095 00096 scalar<T>& operator = (int rhs); 00097 scalar<T>& operator += (int rhs); 00098 scalar<T>& operator -= (int rhs); 00099 scalar<T>& operator *= (int rhs); 00100 scalar<T>& operator /= (int rhs); 00101 scalar<T>& operator %= (int rhs); 00102 00103 scalar<T>& operator = (unsigned long rhs); 00104 scalar<T>& operator += (unsigned long rhs); 00105 scalar<T>& operator -= (unsigned long rhs); 00106 scalar<T>& operator *= (unsigned long rhs); 00107 scalar<T>& operator /= (unsigned long rhs); 00108 scalar<T>& operator %= (unsigned long rhs); 00109 00110 scalar<T>& operator *= (double rhs); 00111 scalar<T>& operator += (double rhs); 00112 00113 scalar<T>& operator = (long rhs); 00114 scalar<T>& operator += (long rhs); 00115 scalar<T>& operator -= (long rhs); 00116 scalar<T>& operator *= (long rhs); 00117 scalar<T>& operator /= (long rhs); 00118 // scalar<T>& operator %= (long rhs); 00119 00120 // template<class S> 00121 // scalar<T>& operator = (const VAL<S> & x) {assign(*this,x.rep());return *this;} 00122 // template<class S> 00123 // scalar<T>& operator += (const VAL<S> & x) 00124 // {scalar<T> tmp(x);*this+=tmp;return *this;} 00125 // template<class S> 00126 // scalar<T>& operator -= (const VAL<S> & x) 00127 // {scalar<T> tmp(x); *this-=tmp;return *this;} 00128 // template<class S> scalar<T>& operator *= (const VAL<S> & x) 00129 // {scalar<T> tmp(x); *this*=tmp;return *this;} 00130 // template<class S> scalar<T>& operator /= (const VAL<S> & x) 00131 // {scalar<T> tmp(x); *this/=tmp;return *this;} 00132 // template<class S> scalar<T>& operator %= (const VAL<S> & x) 00133 // {scalar<T> tmp(x); *this%=tmp;return *this;} 00134 00135 //----------------------------------------------------------------- 00136 void operator ++ ( ); 00137 void operator -- ( ); 00138 //----------------------------------------------------------------- 00139 void Div2Exp (unsigned long exponent_of_2); 00140 void GCD (const scalar<T>& b2); 00141 void Mod2Exp (unsigned long exponent_of_2); 00142 void Mul2Exp (unsigned long exponent_of_2); 00143 void PowMod (const scalar<T>& exp, const scalar<T>& m); 00144 void PowMod (unsigned long exp, const scalar<T>& m); 00145 void abs ( ); 00146 void factorial (unsigned long n); 00147 scalar<T>& negate ( ); 00148 scalar<T>& pow (unsigned long exp); 00149 scalar<T>& pow (unsigned long base, unsigned long exp); 00150 void quo (const scalar<T>& divisor); 00151 void quo (unsigned long divisor); 00152 void rem (const scalar<T>& divisor); 00153 unsigned long rem (unsigned long divisor); 00154 void sqrt ( ); 00155 00156 private: 00157 void init(); 00158 }; 00159 00160 //====================================================================== 00161 // THE ARITHMETIC OPERATORS 00162 //====================================================================== 00163 // template<class T> scalar<T>& operator - (const scalar<T>& b); 00164 // template<class T> scalar<T>& operator + (const scalar<T>& b1, const scalar<T>& b2); 00165 // template<class T> scalar<T>& operator - (const scalar<T>& b1, const scalar<T>& b2); 00166 // template<class T> scalar<T>& operator * (const scalar<T>& b1, const scalar<T>& b2); 00167 // template<class T> scalar<T>& operator / (const scalar<T>& b1, const scalar<T>& b2); 00168 // template<class T> scalar<T>& operator % (const scalar<T>& b1, const scalar<T>& b2); 00169 //----------------------------------------------------------------------} 00170 // template <class R> inline 00171 // VAL<OP<'+',scalar<R>,scalar<R> > > operator+(const scalar<R> & a, const scalar<R> & b) 00172 // { 00173 // return VAL<OP<'+',scalar<R>,scalar<R> > >(OP<'+',scalar<R>,scalar<R> >(a,b)); 00174 // } 00175 // //---------------------------------------------------------------------- 00176 // template <class R> inline 00177 // VAL<OP<'-',scalar<R>,scalar<R> > > operator-(const scalar<R> & a, const scalar<R> & b) 00178 // { 00179 // return VAL<OP<'-',scalar<R>,scalar<R> > >(OP<'-',scalar<R>,scalar<R> >(a,b)); 00180 // } 00181 // //----------------------------------------------------------------------} 00182 // template<class T> inline 00183 // scalar<T>& operator - (const scalar<T>& b) 00184 // { 00185 // scalar<T> r(b); return (r.negate()); 00186 // } 00187 // //---------------------------------------------------------------------- 00188 // // Product of polynomials 00189 // template <class R> inline 00190 // VAL<OP<'*',scalar<R>,scalar<R> > > operator*(const scalar<R> & a, const scalar<R> & b) 00191 // { 00192 // return VAL<OP<'*',scalar<R>,scalar<R> > >(OP<'*',scalar<R>,scalar<R> >(a,b)); 00193 // } 00194 // //---------------------------------------------------------------------- 00195 // // Division of polynomials 00196 // template <class R> inline 00197 // VAL<OP<'/',scalar<R>,scalar<R> > > operator/(const scalar<R> & a, const scalar<R> & b) 00198 // { 00199 // return VAL<OP<'/',scalar<R>,scalar<R> > >(OP<'/',scalar<R>,scalar<R> >(a,b)); 00200 // } 00201 // //---------------------------------------------------------------------- 00202 // // Division of polynomials 00203 // template <class R> inline 00204 // VAL<OP<'%',scalar<R>,scalar<R> > > operator%(const scalar<R> & a, const scalar<R> & b) 00205 // { 00206 // return VAL<OP<'%',scalar<R>,scalar<R> > >(OP<'%',scalar<R>,scalar<R> >(a,b)); 00207 // } 00208 //---------------------------------------------------------------------- 00209 template<class T> scalar<T>& operator + (const scalar<T>& b, unsigned long ul); 00210 template<class T> scalar<T>& operator - (const scalar<T>& b, unsigned long ul); 00211 template<class T> scalar<T>& operator * (const scalar<T>& b, unsigned long ul); 00212 template<class T> scalar<T>& operator / (const scalar<T>& b, unsigned long ul); 00213 template<class T> scalar<T>& operator % (const scalar<T>& b, unsigned long ul); 00214 00215 template<class T> scalar<T>& operator + (unsigned long ul, const scalar<T>& b); 00216 template<class T> scalar<T>& operator * (unsigned long ul, const scalar<T>& b); 00217 00218 template<class T> scalar<T>& operator + (const scalar<T>& b, long sl); 00219 template<class T> scalar<T>& operator - (const scalar<T>& b, long sl); 00220 template<class T> scalar<T>& operator * (const scalar<T>& b, long sl); 00221 template<class T> scalar<T>& operator / (const scalar<T>& b, long sl); 00222 template<class T> scalar<T>& operator % (const scalar<T>& b, long sl); 00223 00224 template<class T> scalar<T>& operator + (long sl, const scalar<T>& b); 00225 template<class T> scalar<T>& operator * (int sl, const scalar<T>& b); 00226 template<class T> scalar<T>& operator * (long sl, const scalar<T>& b); 00227 template<class T> scalar<T>& operator * (double d, const scalar<T>& b); 00228 //---------------------------------------------------------------------- 00229 template<class T> scalar<T>& Div2Exp (const scalar<T>& b, 00230 unsigned long exponent_of_2); 00231 template<class T> scalar<T>& GCD (const scalar<T>& b1, const scalar<T>& b2); 00232 template<class T> scalar<T>& gcd (const scalar<T>& b1, const scalar<T>& b2); 00233 template<class T> scalar<T>& Mod2Exp (const scalar<T>& b, 00234 unsigned long exponent_of_2); 00235 template<class T> scalar<T>& Mul2Exp (const scalar<T>& b, unsigned long exponent_of_2); 00236 template<class T> scalar<T>& PowMod (const scalar<T>& b, const scalar<T>& exp, const scalar<T>& m); 00237 template<class T> scalar<T>& PowMod (const scalar<T>& b, unsigned long exp, 00238 const scalar<T>& m); 00239 template<class T> scalar<T> abs (const scalar<T>& b); 00240 template<class T> scalar<T>& neg (const scalar<T>& b); 00241 template<class T> scalar<T> pow (const scalar<T>& base, unsigned long exp); 00242 template<class T> scalar<T>& quo (const scalar<T>& dividend, unsigned long divisor); 00243 template<class T> scalar<T>& rem (const scalar<T>& dividend, const scalar<T>& divisor); 00244 template<class T> unsigned long rem (const scalar<T>& b, unsigned long divisor); 00245 template<class T> scalar<T> sqrt (const scalar<T>& b); 00246 00247 00248 template<class T> scalar<T>& BigIntFactorial (unsigned long n); 00249 00250 // 00251 // -------- the corresponding `const' functions ----------------------------- 00252 // 00253 00254 #define NO_NRV 1 00255 #if defined(__GNUG__) && !defined(NO_NRV) 00256 #define NRVAL(name) return name 00257 #define NRCODE(code) code 00258 #define NONRCODE(code) 00259 #else 00260 #define NRVAL(name) 00261 #define NRCODE(code) 00262 #define NONRCODE(code) code 00263 #endif // 00264 00265 #define OPCODE(a, b, op) scalar<T>& r =*new scalar<T>(a); return (r op b); 00266 00267 00268 // template<class T> inline 00269 // scalar<T>& operator + (const scalar<T>& b1, const scalar<T>& b2) 00270 // { 00271 // OPCODE(b1,b2,+=) 00272 // } 00273 00274 // template<class T> inline 00275 // scalar<T>& operator - (const scalar<T>& b1, const scalar<T>& b2) 00276 // { 00277 // OPCODE(b1,b2,-=) 00278 // } 00279 00280 // template<class T> inline 00281 // scalar<T>& operator * (const scalar<T>& b1, const scalar<T>& b2) 00282 // { 00283 // OPCODE(b1,b2,*=) 00284 // } 00285 00286 // template<class T> inline 00287 // scalar<T>& operator / (const scalar<T>& b1, const scalar<T>& b2) 00288 // { 00289 // OPCODE(b1,b2,/=) 00290 // } 00291 00292 // template<class T> inline 00293 // scalar<T>& operator % (const scalar<T>& b1, const scalar<T>& b2) 00294 // { 00295 // OPCODE(b1,b2,%=) 00296 // } 00297 00298 //-------------------------- 00299 template<class T> inline 00300 scalar<T>& operator + (const scalar<T>& b, unsigned long ul) 00301 { 00302 OPCODE(b,ul,+=) 00303 } 00304 00305 template<class T> inline 00306 scalar<T>& operator - (const scalar<T>& b, unsigned long ul) 00307 { 00308 OPCODE(b,ul,-=) 00309 } 00310 00311 template<class T> inline scalar<T>& 00312 operator * (const scalar<T>& b, unsigned long ul) 00313 { 00314 OPCODE(b,ul,*=) 00315 } 00316 00317 template<class T> inline scalar<T>& 00318 operator / (const scalar<T>& b, unsigned long ul) 00319 { 00320 OPCODE(b,ul,/=) 00321 } 00322 00323 template<class T> inline 00324 scalar<T>& operator % (const scalar<T>& b, unsigned long ul) 00325 { 00326 OPCODE(b,ul,%=) 00327 } 00328 00329 //---------------------------------------------------------------------- 00330 template<class T> inline 00331 scalar<T>& operator + (unsigned long ul, const scalar<T>& b) 00332 { 00333 return b + ul; 00334 } 00335 //---------------------------------------------------------------------- 00336 template<class T> inline 00337 scalar<T>& operator * (unsigned long ul, const scalar<T>& b) 00338 { 00339 return b * ul; 00340 } 00341 //---------------------------------------------------------------------- 00342 template<class T> inline 00343 scalar<T>& operator + (const scalar<T>& b, unsigned sl) NRVAL(r(b)) { OPCODE(b,sl,+=) } 00344 00345 template<class T> inline 00346 scalar<T>& operator - (const scalar<T>& b, unsigned sl) NRVAL(r(b)) { OPCODE(b,sl,-=) } 00347 00348 template<class T> inline 00349 scalar<T>& operator * (const scalar<T>& b, unsigned sl) NRVAL(r(b)) { OPCODE(b,sl,*=) } 00350 00351 template<class T> inline 00352 scalar<T>& operator / (const scalar<T>& b, unsigned sl) NRVAL(r(b)) { OPCODE(b,sl,/=) } 00353 00354 template<class T> inline 00355 scalar<T>& operator % (const scalar<T>& b, unsigned sl) NRVAL(r(b)) { OPCODE(b,sl,%=) } 00356 //-------------------------------------------------------------------- 00357 template<class T> inline 00358 scalar<T>& operator + (const scalar<T>& b, int sl) NRVAL(r(b)) { OPCODE(b,sl,+=) } 00359 00360 template<class T> inline 00361 scalar<T>& operator - (const scalar<T>& b, int sl) NRVAL(r(b)) { OPCODE(b,sl,-=) } 00362 00363 template<class T> inline 00364 scalar<T>& operator * (const scalar<T>& b, int sl) NRVAL(r(b)) { OPCODE(b,sl,*=) } 00365 00366 template<class T> inline 00367 scalar<T>& operator / (const scalar<T>& b, int sl) NRVAL(r(b)) { OPCODE(b,sl,/=) } 00368 00369 template<class T> inline 00370 scalar<T>& operator % (const scalar<T>& b, int sl) NRVAL(r(b)) { OPCODE(b,sl,%=) } 00371 //---------------------------------------------------------------------- 00372 template<class T> inline 00373 scalar<T>& operator + (const scalar<T>& b, long int sl) NRVAL(r(b)) { OPCODE(b,sl,+=) } 00374 00375 template<class T> inline 00376 scalar<T>& operator - (const scalar<T>& b, long int sl) NRVAL(r(b)) { OPCODE(b,sl,-=) } 00377 00378 template<class T> inline 00379 scalar<T>& operator * (const scalar<T>& b, long int sl) NRVAL(r(b)) { OPCODE(b,sl,*=) } 00380 00381 template<class T> inline 00382 scalar<T>& operator / (const scalar<T>& b, long int sl) NRVAL(r(b)) { OPCODE(b,sl,/=) } 00383 00384 template<class T> inline 00385 scalar<T>& operator % (const scalar<T>& b, long int sl) NRVAL(r(b)) { OPCODE(b,sl,%=) } 00386 00387 00388 00389 //-------------------------- 00390 00391 template<class T> inline 00392 scalar<T>& operator + (long sl, const scalar<T>& b) 00393 { 00394 return b + sl; 00395 } 00396 00397 template<class T> inline 00398 scalar<T>& operator * (long sl, const scalar<T>& b) 00399 { 00400 return b * sl; 00401 } 00402 //-------------------------- 00403 00404 template<class T> inline 00405 scalar<T>& Div2Exp (const scalar<T>& b, unsigned long exponent_of_2) NRVAL(r(b)) 00406 { 00407 NRCODE(r.Div2Exp(exponent_of_2);) 00408 NONRCODE(scalar<T> r(b); r.Div2Exp(exponent_of_2); return r;) 00409 } 00410 00411 template<class T> inline 00412 scalar<T>& GCD (const scalar<T>& b1, const scalar<T>& b2) NRVAL(r(b1)) 00413 { 00414 NRCODE(r.GCD(b2);) 00415 NONRCODE(scalar<T> r(b1); r.GCD(b2); return r;) 00416 } 00417 00418 template<class T> inline 00419 scalar<T>& gcd (const scalar<T>& b1, const scalar<T>& b2) NRVAL(r(b1)) 00420 { 00421 NRCODE(r.GCD(b2);) 00422 NONRCODE(scalar<T> r(b1); r.GCD(b2); return r;) 00423 } 00424 00425 template<class T> inline 00426 scalar<T>& Mod2Exp (const scalar<T>& b, unsigned long exponent_of_2) NRVAL(r(b)) 00427 { 00428 NRCODE(r.Mod2Exp(exponent_of_2);) 00429 NONRCODE(scalar<T> r(b); r.Mod2Exp(exponent_of_2); return r;) 00430 } 00431 00432 template<class T> inline 00433 scalar<T>& Mul2Exp (const scalar<T>& b, unsigned long exponent_of_2) NRVAL(r(b)) 00434 { 00435 NRCODE(r.Mul2Exp(exponent_of_2);) 00436 NONRCODE(scalar<T> r(b); r.Mul2Exp(exponent_of_2); return r;) 00437 } 00438 00439 template<class T> inline 00440 scalar<T>& PowMod (const scalar<T>& b, const scalar<T>& exp, const scalar<T>& m) NRVAL(r(b)) 00441 { 00442 NRCODE(r.PowMod(exp, m);) 00443 NONRCODE(scalar<T> r(b); r.PowMod(exp,m); return r;) 00444 } 00445 00446 template<class T> inline 00447 scalar<T>& PowMod (const scalar<T>& b, unsigned long exp, const scalar<T>& m) NRVAL(r(b)) 00448 { 00449 NRCODE(r.PowMod(exp, m);) 00450 NONRCODE(scalar<T> r(b); r.PowMod(exp,m); return r;) 00451 } 00452 00453 //template<class T> inline scalar<T> 00454 template <class T> inline 00455 scalar<T> abs (const scalar<T>& b) NRVAL(r(b)) 00456 { 00457 NRCODE(r.abs();) 00458 NONRCODE(scalar<T> r(b); r.abs(); return r;) 00459 } 00460 00461 // template<class T> inline scalar<T>& 00462 // negate (const scalar<T>& b) NRVAL(r(b)) 00463 // { 00464 // NRCODE(r.negate();) 00465 // NONRCODE(scalar<T> r(b); r.negate(); return r;) 00466 // } 00467 00468 template<class T> inline 00469 scalar<T> pow (const scalar<T>& base, unsigned long exp) NRVAL(r(base)) 00470 { 00471 NRCODE(r.pow(exp);) 00472 NONRCODE(scalar<T> r(base); r.pow(exp); return r;) 00473 } 00474 00475 template<class T> inline 00476 scalar<T> quo (const scalar<T>& dividend, const scalar<T>& divisor) NRVAL(r(dividend)) 00477 { 00478 NRCODE(r.quo(divisor);) 00479 NONRCODE(scalar<T> r(dividend); r.quo(divisor); return r;) 00480 } 00481 00482 template<class T> inline 00483 scalar<T> quo (const scalar<T>& dividend, unsigned long divisor) NRVAL(r(dividend)) 00484 { 00485 NRCODE(r.quo(divisor);) 00486 NONRCODE(scalar<T> r(dividend); r.quo(divisor); return r;) 00487 } 00488 00489 template<class T> inline 00490 scalar<T>& rem (const scalar<T>& dividend, const scalar<T>& divisor) NRVAL(r(dividend)) 00491 { 00492 NRCODE(r.rem(divisor);) 00493 NONRCODE(scalar<T> r(dividend); r.rem(divisor); return r;) 00494 } 00495 00496 template<class T> inline 00497 scalar<T> sqrt (const scalar<T>& b) NRVAL(r(b)) 00498 { 00499 NRCODE(r.sqrt();) 00500 NONRCODE(scalar<T> r(b); r.sqrt(); return r;) 00501 } 00502 00503 template<class T> inline 00504 unsigned long rem (const scalar<T>& b, unsigned long divisor) 00505 { 00506 scalar<T> r(b); 00507 return r.rem(divisor); 00508 } 00509 00510 template<class T> inline 00511 scalar<T>& BigIntFactorial (unsigned long n) NRVAL(r) 00512 { 00513 NRCODE(r.factorial(n);) 00514 NONRCODE(scalar<T> r; r.factorial(n); return r;) 00515 } 00516 00517 template<class T> inline 00518 scalar<T>& BigIntPow (unsigned long base, unsigned long exp) NRVAL(r) 00519 { 00520 NRCODE(r.pow(base, exp);) 00521 NONRCODE(scalar<T> r; r.pow(base, exp); return r;) 00522 } 00523 00524 template<class T> 00525 scalar<T> Size(const scalar<T> & r) 00526 { 00527 return abs(r); 00528 } 00529 //---------------------------------------------------------------------- 00530 } //namespace mmx 00531 //====================================================================== 00532 #undef NRVAL 00533 #undef NRCODE 00534 #undef NONRCODE 00535 #endif // //scalar_H 00536 00537 00538 00539
