realroot: include/realroot/scalar_extended

00001 /********************************************************************
00002  *   This file is part of the source code of the realroot library.
00003  *   Author(s): P. Dobrowolski, Warsaw University of Technology, Poland
00004  *   $Id: scalar_extended_rational.hpp,v 1.1 2012/02/22 20:00:00 pdobrowolski Exp $
00005  ********************************************************************/
00006 #ifndef REALROOT_SCALAR_EXTENDED_RATIONAL_H_
00007 #define REALROOT_SCALAR_EXTENDED_RATIONAL_H_
00008 //----------------------------------------------------------------------
00009 #include <string>
00010 #include <iostream>
00011 #include <realroot/extended.hpp>
00012 #include <realroot/scalar_rational.hpp>
00013 #include <realroot/scalar_extended_integer.hpp>
00014 #include <cassert>
00015 //======================================================================
00016 namespace mmx {
00017 //----------------------------------------------------------------------
00018 typedef extended<MPQ> EMPQ;
00019 //----------------------------------------------------------------------
00020 std::ostream& operator <<(std::ostream& os, const scalar<EMPQ>& b);
00021 //----------------------------------------------------------------------
00022 template<> inline
00023 void scalar<EMPQ>::init() {}
00024 //------------------- scalar<T>(...) -------------------------------------
00025 template<> inline
00026 scalar<EMPQ>::scalar() : data() {}
00027 //----------------------------------------------------------------------
00028 template<> inline
00029 scalar<EMPQ>::~scalar() {}
00030 //----------------------------------------------------------------------
00031 template<> inline
00032 scalar<EMPQ>::scalar(int si) : data(scalar<MPQ>(si)) {}
00033 //----------------------------------------------------------------------
00034 template<> inline
00035 scalar<EMPQ>::scalar(unsigned si) : data(scalar<MPQ>(si)) {}
00036 //----------------------------------------------------------------------
00037 template<> inline
00038 scalar<EMPQ>::scalar(const char *string, unsigned int base) : data(scalar<MPQ>(string, base)) {}
00039 //----------------------------------------------------------------------
00040 template<> template<class U>
00041 inline scalar<EMPQ>::scalar(const scalar<U> &a, const scalar<U> &b, const scalar<U> &c) : data(a, b, c) {}
00042 //----------------------------------------------------------------------
00043 template<> inline
00044 scalar<EMPQ>::scalar(signed long int sl) : data(scalar<MPQ>(sl)) {}
00045 //----------------------------------------------------------------------
00046 template<> inline
00047 scalar<EMPQ>::scalar(unsigned long int ul) : data(scalar<MPQ>(ul)) {}
00048 //----------------------------------------------------------------------
00049 template<> inline
00050 scalar<EMPQ>::scalar(const scalar<EMPQ>& rhs) : data(rhs.rep()) {}
00051 //----------------------------------------------------------------------
00052 template<> inline
00053 scalar<EMPQ>::scalar(double rhs) : data(scalar<MPQ>(rhs)) {}
00054 //----------------------------------------------------------------------
00055 template<> inline
00056 scalar<EMPQ>& scalar<EMPQ>::operator =(const scalar<EMPQ>& rhs) { rep() = rhs.rep(); return *this; }
00057 //----------------------------------------------------------------------
00058 template<> inline
00059 bool scalar<EMPQ>::operator ==(const scalar<EMPQ>& rhs) const { return rep() == rhs.rep(); }
00060 
00061 template<> inline
00062 bool scalar<EMPQ>::operator ==(long sl) const { return rep() == EMPQ(sl); }
00063 
00064 template<> inline
00065 bool scalar<EMPQ>::operator ==(int si) const { return rep() == EMPQ(si); }
00066 
00067 template<> inline
00068 bool scalar<EMPQ>::operator ==(unsigned long ul) const { return rep() == EMPQ(ul); }
00069 
00070 // != ------------------------------------------------------------------
00071 template<> inline
00072 bool scalar<EMPQ>::operator !=(const scalar<EMPQ>& rhs) const { return rep() != rhs.rep(); }
00073 
00074 template<> inline
00075 bool scalar<EMPQ>::operator !=(long sl) const { return rep() != EMPQ(sl); }
00076 
00077 template<> inline
00078 bool scalar<EMPQ>::operator !=(int si) const { return rep() != EMPQ(si); }
00079 
00080 template<> inline
00081 bool scalar<EMPQ>::operator !=(unsigned long ul) const { return rep() != EMPQ(ul); }
00082 
00083 // > -------------------------------------------------------------------
00084 template<> inline
00085 bool scalar<EMPQ>::operator >(const scalar<EMPQ>& rhs) const { return rep() > rhs.rep(); }
00086 
00087 template<> inline
00088 bool scalar<EMPQ>::operator >(long sl) const { return rep() > EMPQ(sl); }
00089 
00090 template<> inline
00091 bool scalar<EMPQ>::operator >(int si) const { return rep() > EMPQ(si); }
00092 
00093 template<> inline
00094 bool scalar<EMPQ>::operator >(unsigned long ul) const { return rep() > EMPQ(ul); }
00095 
00096 // <= --------------------------------------------------------------------
00097 template<> inline
00098 bool scalar<EMPQ>::operator >=(const scalar<EMPQ>& rhs) const { return rep() >= rhs.rep(); }
00099 
00100 template<> inline
00101 bool scalar<EMPQ>::operator >=(long sl) const { return rep() >= EMPQ(sl); }
00102 
00103 template<> inline
00104 bool scalar<EMPQ>::operator >=(int si) const { return rep() >= EMPQ(si); }
00105 
00106 template<> inline
00107 bool scalar<EMPQ>::operator >=(unsigned long ul) const { return rep() >= EMPQ(ul); }
00108 
00109 // < -------------------------------------------------------------------
00110 template<> inline
00111 bool scalar<EMPQ>::operator <(const scalar<EMPQ>& rhs) const { return rep() < rhs.rep(); }
00112 
00113 template<> inline
00114 bool scalar<EMPQ>::operator <(long sl) const { return rep() < EMPQ(sl); }
00115 
00116 template<> inline
00117 bool scalar<EMPQ>::operator <(int si) const { return rep() < EMPQ(si); }
00118 
00119 template<> inline
00120 bool scalar<EMPQ>::operator <(unsigned long ul) const { return rep() < EMPQ(ul); }
00121 
00122 // <= ------------------------------------------------------------------
00123 template<> inline
00124 bool scalar<EMPQ>::operator <=(const scalar<EMPQ>& rhs) const { return rep() <= rhs.rep(); }
00125 
00126 template<> inline
00127 bool scalar<EMPQ>::operator <=(long sl) const { return rep() <= EMPQ(sl); }
00128 
00129 template<> inline
00130 bool scalar<EMPQ>::operator <=(int si) const { return rep() <= EMPQ(si); }
00131 
00132 template<> inline
00133 bool scalar<EMPQ>::operator <=(unsigned long ul) const { return rep() <= EMPQ(ul); }
00134 
00135 // = -------------------------------------------------------------------
00136 template<> inline
00137 scalar<EMPQ>&  scalar<EMPQ>::operator =(unsigned long ul) { rep() = EMPQ(ul); return *this;}
00138 
00139 template<> inline
00140 scalar<EMPQ>& scalar<EMPQ>::operator =(long sl) { rep() = EMPQ(sl); return *this;}
00141 
00142 template<> inline
00143 scalar<EMPQ>& scalar<EMPQ>::operator =(int si) { rep() = EMPQ(si); return *this;}
00144 
00145 // += -------------------------------------------------------------------
00146 template<> inline
00147 scalar<EMPQ>& scalar<EMPQ>::operator +=(const scalar<EMPQ>& rhs) { rep() += rhs.rep(); return *this; }
00148 
00149 template<> inline
00150 scalar<EMPQ>& scalar<EMPQ>::operator +=(unsigned long ul) { rep() += EMPQ(ul); return *this;}
00151 
00152 template<> inline
00153 scalar<EMPQ>& scalar<EMPQ>::operator +=(long sl) { rep() += EMPQ(sl); return *this;}
00154 
00155 template<> inline
00156 scalar<EMPQ>& scalar<EMPQ>::operator +=(int si) { rep() += EMPQ(si); return *this;}
00157 
00158 // -= -------------------------------------------------------------------
00159 template<> inline
00160 scalar<EMPQ>& scalar<EMPQ>::operator -=(const scalar<EMPQ>& rhs) { rep() -= rhs.rep(); return *this; }
00161 
00162 template<> inline
00163 scalar<EMPQ>& scalar<EMPQ>::operator -=(unsigned long ul) { rep() -= EMPQ(ul); return *this;}
00164 
00165 template<> inline
00166 scalar<EMPQ>& scalar<EMPQ>::operator -=(long sl) { rep() -= EMPQ(sl); return *this;}
00167 
00168 template<> inline
00169 scalar<EMPQ>& scalar<EMPQ>::operator -=(int si) { rep() -= EMPQ(si); return *this;}
00170 
00171 // *= -----------------------------------------------------------------
00172 template<> inline
00173 scalar<EMPQ>& scalar<EMPQ>::operator *=(const scalar<EMPQ>& rhs) { rep() *= rhs.rep(); return *this; }
00174 
00175 template<> inline
00176 scalar<EMPQ>& scalar<EMPQ>::operator *=(unsigned long ul) { rep() *= EMPQ(ul); return *this;}
00177 
00178 template<> inline
00179 scalar<EMPQ>& scalar<EMPQ>::operator *=(long sl) { rep() *= EMPQ(sl); return *this;}
00180 
00181 template<> inline
00182 scalar<EMPQ>& scalar<EMPQ>::operator *=(int si) { rep() *= EMPQ(si); return *this;}
00183 
00184 // /= ------------------------------------------------------------------
00185 template<> inline
00186 scalar<EMPQ>& scalar<EMPQ>::operator /=(const scalar<EMPQ>& rhs) { rep() /= rhs.rep(); return *this; }
00187 
00188 template<> inline
00189 scalar<EMPQ>& scalar<EMPQ>::operator /=(unsigned long ul) { rep() /= EMPQ(ul); return *this;}
00190 
00191 template<> inline
00192 scalar<EMPQ>& scalar<EMPQ>::operator /=(long sl) { rep() /= EMPQ(sl); return *this;}
00193 
00194 template<> inline
00195 scalar<EMPQ>& scalar<EMPQ>::operator /=(int si) { rep() /= EMPQ(si); return *this;}
00196 
00197 //======================================================================
00198 // ARITHMETIC OPERATORS
00199 //======================================================================
00200 inline
00201 scalar<EMPQ> operator +(const scalar<EMPQ>& a1, const scalar<EMPQ>& a2)
00202 {
00203     scalar<EMPQ> result;
00204     result.rep() = a1.rep() + a2.rep();
00205     return result;
00206 }
00207 //----------------------------------------------------------------------
00208 inline
00209 scalar<EMPQ> operator -(const scalar<EMPQ>& a1, const scalar<EMPQ>& a2)
00210 {
00211     scalar<EMPQ> result;
00212     result.rep() = a1.rep() - a2.rep();
00213     return result;
00214 }
00215 //----------------------------------------------------------------------
00216 inline
00217 scalar<EMPQ> operator -(const scalar<EMPQ>& a1)
00218 {
00219     scalar<EMPQ> result;
00220     result.rep() = -a1.rep();
00221     return result;
00222 }
00223 //----------------------------------------------------------------------
00224 inline
00225 scalar<EMPQ> operator *(const scalar<EMPQ>& a1, const scalar<EMPQ>& a2)
00226 {
00227     scalar<EMPQ> result;
00228     result.rep() = a1.rep() * a2.rep();
00229     return result;
00230 }
00231 
00232 inline
00233 scalar<EMPQ> operator *(const scalar<EMPQ>& a1, const scalar<EMPZ>& a2)
00234 {
00235     scalar<EMPQ> result;
00236     EMPQ v(scalar<MPQ>(a2.rep().a), scalar<MPQ>(a2.rep().b), scalar<MPQ>(a2.rep().c));
00237     result.rep() = a1.rep() * v;
00238     return result;
00239 }
00240 
00241 inline
00242 scalar<EMPQ> operator *(const scalar<EMPZ>& a1, const scalar<EMPQ>& a2)
00243 {
00244     scalar<EMPQ> result;
00245     EMPQ v(scalar<MPQ>(a1.rep().a), scalar<MPQ>(a1.rep().b), scalar<MPQ>(a1.rep().c));
00246     result.rep() = v * a2.rep();
00247     return result;
00248 }
00249 
00250 inline
00251 scalar<EMPQ> operator *(const scalar<EMPQ>& a1, const scalar<MPQ>& a2)
00252 {
00253     scalar<EMPQ> result;
00254     result.rep() = a1.rep() * EMPQ(a2);
00255     return result;
00256 }
00257 
00258 inline scalar<EMPQ> operator *(const scalar<MPQ>& a1, const scalar<EMPQ>& a2)
00259 {
00260     scalar<EMPQ> result;
00261     result.rep() = EMPQ(a1) * a2.rep();
00262     return result;
00263 }
00264 //--------------------------------------------------------------------
00265 inline
00266 scalar<EMPQ> operator *(const scalar<EMPQ>& a2, int a1)
00267 {
00268     return a2 * scalar<EMPQ>(a1);
00269 }
00270 
00271 inline
00272 scalar<EMPQ> operator *(int a1, const scalar<EMPQ>& a2)
00273 {
00274     scalar<EMPQ> result;
00275     result.rep() = EMPQ(scalar<MPQ>(a1)) * a2.rep();
00276     return result;
00277 }
00278 
00279 inline
00280 scalar<EMPQ> operator /(const scalar<EMPQ>& a1, const scalar<EMPQ>& a2)
00281 {
00282     scalar<EMPQ> result;
00283     result.rep() = a1.rep() / a2.rep();
00284     return result;
00285 }
00286 
00287 inline
00288 scalar<EMPQ> operator /(const scalar<EMPQ>& a1, const scalar<MPQ>& a2)
00289 {
00290     scalar<EMPQ> result;
00291     result.rep() = a1.rep() / EMPQ(a2);
00292     return result;
00293 }
00294 
00295 inline
00296 scalar<EMPQ> operator /(const scalar<EMPQ>& a1, const scalar<EMPZ>& a2)
00297 {
00298     scalar<EMPQ> result;
00299     EMPQ v(scalar<MPQ>(a2.rep().a), scalar<MPQ>(a2.rep().b), scalar<MPQ>(a2.rep().c));
00300     result.rep() = a1.rep() / v;
00301     return result;
00302 }
00303 //======================================================================
00305 template<> inline
00306 void scalar<EMPQ>::operator ++()
00307 {
00308     ++rep().a;
00309 }
00310 //----------------------------------------------------------------------
00312 template<> inline
00313 void scalar<EMPQ>::operator --()
00314 {
00315     --rep().a;
00316 }
00317 //======================================================================
00318 // INPUT OUTPUT
00319 //======================================================================
00320 inline
00321 std::ostream& operator <<(std::ostream& os, const scalar<EMPQ>& b)
00322 {
00323     os << b.rep().a << " + " << b.rep().b << " * sqrt( " << b.rep().c << " )";
00324     return os;
00325 }
00326 
00327 //----------------------------------------------------------------------
00328 //inline
00329 //std::istream& operator >>(std::istream& is, scalar<EMPQ>& b)
00330 //{
00331 //  INVALID_CALL();
00332 //  return is;
00333 //}
00334 //======================================================================
00335 // SPECIAL FUNCTIONS
00336 //======================================================================
00337 template<> inline void
00338 scalar<EMPQ>::abs()
00339 {
00340     if (*this < 0)
00341         *this = -*this;
00342 }
00343 
00344 template<> inline
00345 scalar<EMPQ>& scalar<EMPQ>::negate()
00346 {
00347     *this = -*this;
00348     return *this;
00349 }
00350 
00351 //-------------------------- compare(...) ------------------------------------
00352 inline
00353 int compare(const scalar<EMPQ>& b1, const scalar<EMPQ>& b2) { return EMPQ::compare(b1.rep(), b2.rep()); }
00354 
00355 inline
00356 int compare(const scalar<EMPQ>& b, unsigned long ul) { return EMPQ::compare(b.rep(), EMPQ(scalar<MPQ>(ul))); }
00357 
00358 inline
00359 int compare(const scalar<EMPQ>& b, long sl) { return EMPQ::compare(b.rep(), EMPQ(scalar<MPQ>(sl))); }
00360 
00361 inline
00362 int compare(const scalar<EMPQ>& b, int si) { return EMPQ::compare(b.rep(), EMPQ(scalar<MPQ>(si))); }
00363 
00364 inline
00365 scalar<EMPQ> min(const scalar<EMPQ>& a1, const scalar<EMPQ>& a2) { return a1 < a2 ? a1 : a2; }
00366 
00367 inline
00368 scalar<EMPQ> max(const scalar<EMPQ>& a1, const scalar<EMPQ>& a2) { return a1 > a2 ? a1 : a2; }
00369 
00370 //--------------------------------------------------------------------
00371 namespace let
00372 {
00373 inline void assign(scalar<MPQ>& x, const scalar<EMPQ>& r) { assert(0); }
00374 inline void assign(scalar<EMPQ>& x, const scalar<EMPZ>& r)
00375 {
00376     x.rep() = EMPQ(scalar<MPQ>(r.rep().a),
00377                    scalar<MPQ>(r.rep().b),
00378                    scalar<MPQ>(r.rep().c));
00379 }
00380 }
00381 
00382 template<typename T,typename F> struct as_helper;
00383 
00384 template<> struct as_helper<double,scalar<EMPQ> > {
00385     static inline double cv(const scalar<EMPQ>& x) {double r; let::assign(r,x); return r;}
00386 };
00387 
00388 
00389 template<> struct as_helper<scalar<EMPQ>,scalar<EMPZ> > {
00390     static inline scalar<EMPQ> cv(const scalar<EMPZ>& x) {
00391         scalar<EMPQ> r;
00392         let::assign(r,x);
00393         return r;}
00394 };
00395 } //namespace mmx
00396 //======================================================================
00397 #endif // REALROOT_SCALAR_EXTENDED_RATIONAL_H_
include/realroot/scalar_extended_rational.hpp
