realroot: include/realroot/scalar.hpp Source File

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