Quantity: Dynamic.h Source File

00001 
00005 /* Copyright (C) 2002 - 2005, Bernd Speiser */
00006 /* This file is part of Quantity.
00007 
00008 Quantity is free software; you can redistribute it and/or
00009 modify it under the terms of the GNU General Public License
00010 as published by the Free Software Foundation; either version 2
00011 of the License, or (at your option) any later version.
00012 
00013 Quantity is distributed in the hope that it will be useful,
00014 but WITHOUT ANY WARRANTY; without even the implied warranty of
00015 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016 GNU General Public License for more details.
00017   
00018 You should have received a copy of the GNU General Public License
00019 along with this program; if not, write to the Free Software
00020 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
00021 02111-1307, USA.
00022 */
00023 
00024 #ifndef _Dynamic_h
00025 #define _Dynamic_h
00026 
00027 #include "Quantity/Quantity.h"
00028 #include "Quantity/QuantityError.h"
00029 
00030 namespace quantity {
00031 
00033 //
00034 //  the Dynamic quantity
00035 //
00037 
00039 
00045 template<class ST>
00046   class Dynamic
00047   {
00048     private:
00049       ST _value;
00050 
00051     public:
00052       const long _rl_n;
00053       const long _rl_d;
00054       const long _rm_n;
00055       const long _rm_d;
00056       const long _rt_n;
00057       const long _rt_d;
00058       const long _re_n;
00059       const long _re_d;
00060       const long _rte_n;
00061       const long _rte_d;
00062       const long _ra_n;
00063       const long _ra_d;
00064       const long _rlu_n;
00065       const long _rlu_d;
00066 
00067     private:
00069 
00071       Dynamic (void);
00072 
00074 
00082       Dynamic 
00083         (const long rl_n, const long rl_d, 
00084           const long rm_n, const long rm_d,
00085             const long rt_n, const long rt_d,
00086               const long re_n, const long re_d,
00087                 const long rte_n, const long rte_d,
00088                   const long ra_n, const long ra_d,
00089                      const long rlu_n, const long rlu_d, const ST value)
00090         : _value (value), 
00091            _rl_n (rl_n/BSUtilities::gcd(rl_n, rl_d)), 
00092             _rl_d (rl_d/BSUtilities::gcd(rl_n, rl_d)), 
00093              _rm_n (rm_n/BSUtilities::gcd(rm_n, rm_d)), 
00094               _rm_d (rm_d/BSUtilities::gcd(rm_n, rm_d)),
00095                _rt_n (rt_n/BSUtilities::gcd(rt_n, rt_d)), 
00096                 _rt_d (rt_d/BSUtilities::gcd(rt_n, rt_d)), 
00097                  _re_n (re_n/BSUtilities::gcd(re_n, re_d)), 
00098                   _re_d (re_d/BSUtilities::gcd(re_n, re_d)),
00099                    _rte_n (rte_n/BSUtilities::gcd(rte_n, rte_d)), 
00100                     _rte_d (rte_d/BSUtilities::gcd(rte_n, rte_d)), 
00101                      _ra_n (ra_n/BSUtilities::gcd(ra_n, ra_d)), 
00102                       _ra_d (ra_d/BSUtilities::gcd(ra_n, ra_d)),
00103                        _rlu_n (rlu_n/BSUtilities::gcd(rlu_n, rlu_d)), 
00104                         _rlu_d (rlu_d/BSUtilities::gcd(rlu_n, rlu_d)) {}
00105 
00106     public:
00108       Dynamic (const Dynamic &dynamic)
00109         : _value (dynamic._value),
00110             _rl_n (dynamic._rl_n), _rl_d (dynamic._rl_d), 
00111               _rm_n (dynamic._rm_n), _rm_d (dynamic._rm_d),
00112                 _rt_n (dynamic._rt_n), _rt_d (dynamic._rt_d), 
00113                   _re_n (dynamic._re_n), _re_d (dynamic._re_d),
00114                     _rte_n (dynamic._rte_n), _rte_d (dynamic._rte_d),
00115                       _ra_n (dynamic._ra_n), _ra_d (dynamic._ra_d),
00116                         _rlu_n (dynamic._rlu_n), _rlu_d (dynamic._rlu_d)
00117                                                                       {}
00118 
00120       void operator= (const Dynamic &dynamic)
00121         {_rl_n = dynamic._rl_n; 
00122          _rl_d = dynamic._rl_d; 
00123          _rm_n = dynamic._rm_n; 
00124          _rm_d = dynamic._rm_d;
00125          _rt_n = dynamic._rt_n; 
00126          _rt_d = dynamic._rt_d; 
00127          _re_n = dynamic._re_n; 
00128          _re_d = dynamic._re_d;
00129          _rte_n = dynamic._rte_n; 
00130          _rte_d = dynamic._rte_d;
00131          _ra_n = dynamic._ra_n; 
00132          _ra_d = dynamic._ra_d;
00133          _rlu_n = dynamic._rlu_n; 
00134          _rlu_d = dynamic._rlu_d; 
00135          _value = dynamic._value;
00136         }
00137 
00139     ST value (void) const {return _value;}
00140 
00142 
00144     Dynamic operator*= (const ST factor) 
00145                                        {_value *= factor; return *this;}
00146 
00147 //* operator* for right hand side multiplication with an ST
00151     Dynamic operator* (const ST factor) 
00152                                      {return Dynamic (*this) *= factor;}
00153 
00155 
00157     Dynamic operator/= (const ST divisor) 
00158                                       {_value /= divisor; return *this;}
00159 
00160 //* operator/ for right hand side division by an ST
00164     Dynamic operator/ (const ST divisor) 
00165                                     {return Dynamic (*this) /= divisor;}
00166 
00168 
00170     Dynamic operator+ (void) const {return Dynamic (*this);}
00171 
00173 
00176     Dynamic operator- (void) const 
00177                                   {return Dynamic (*this) *= ST (-1.0);}
00178 
00180 
00186   template<template<class, class> class Q1, class BT1, 
00187     long RL_N, long RL_D, long RM_N, long RM_D,
00188       long RT_N, long RT_D, long RE_N, long RE_D,
00189         long RTE_N, long RTE_D, long RA_N, long RA_D,
00190           long RLU_N, long RLU_D, class UL1, class DU1, class SU1>
00191     bool operator== (const Q1<Quantity<
00192       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
00193         BSUtilities::Rational<RM_N, RM_D>,
00194           BSUtilities::Rational<RT_N, RT_D>,
00195             BSUtilities::Rational<RE_N, RE_D>,
00196               BSUtilities::Rational<RTE_N, RTE_D>,
00197                 BSUtilities::Rational<RA_N, RA_D>,
00198                   BSUtilities::Rational<RLU_N, RLU_D> >,
00199                                      BT1, UL1, DU1, ST>, SU1> &quantity)
00200       {if (_rl_n == RL_N/BSUtilities::Gcd<RL_N, RL_D>::RET
00201          && _rl_d == RL_D/BSUtilities::Gcd<RL_N, RL_D>::RET
00202          && _rm_n == RM_N/BSUtilities::Gcd<RM_N, RM_D>::RET
00203          && _rm_d == RM_D/BSUtilities::Gcd<RM_N, RM_D>::RET
00204          && _rt_n == RT_N/BSUtilities::Gcd<RT_N, RT_D>::RET
00205          && _rt_d == RT_D/BSUtilities::Gcd<RT_N, RT_D>::RET
00206          && _re_n == RE_N/BSUtilities::Gcd<RE_N, RE_D>::RET
00207          && _re_d == RE_D/BSUtilities::Gcd<RE_N, RE_D>::RET
00208          && _rte_n == RTE_N/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00209          && _rte_d == RTE_D/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00210          && _ra_n == RA_N/BSUtilities::Gcd<RA_N, RA_D>::RET
00211          && _ra_d == RA_D/BSUtilities::Gcd<RA_N, RA_D>::RET
00212          && _rlu_n == RLU_N/BSUtilities::Gcd<RLU_N, RLU_D>::RET
00213          && _rlu_d == RLU_D/BSUtilities::Gcd<RLU_N, RLU_D>::RET)
00214 
00215          return value () == quantity.standard_value ();
00216 
00217          else
00218            {throw DimensionMismatch ();}
00219 
00220           }
00221 
00223 
00229     bool operator== (Dynamic<ST> quantity)
00230       {if (_rl_n == quantity._rl_n
00231          && _rl_d == quantity._rl_d
00232          && _rm_n == quantity._rm_n
00233          && _rm_d == quantity._rm_d
00234          && _rt_n == quantity._rt_n
00235          && _rt_d == quantity._rt_d
00236          && _re_n == quantity._re_n
00237          && _re_d == quantity._re_d 
00238          && _rte_n == quantity._rte_n 
00239          && _rte_d == quantity._rte_d
00240          && _ra_n == quantity._ra_n
00241          && _ra_d == quantity._ra_d
00242          && _rlu_n == quantity._rlu_n
00243          && _rlu_d == quantity._rlu_d)
00244 
00245          return value () == quantity.value ();
00246 
00247          else
00248            {throw DimensionMismatch ();}
00249 
00250           }
00251 
00253 
00259   template<template<class, class> class Q1, class BT1, 
00260     long RL_N, long RL_D, long RM_N, long RM_D,
00261       long RT_N, long RT_D, long RE_N, long RE_D,
00262         long RTE_N, long RTE_D, long RA_N, long RA_D,
00263           long RLU_N, long RLU_D, class UL1, class DU1, class SU1>
00264     bool operator!= (const Q1<Quantity<
00265       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
00266         BSUtilities::Rational<RM_N, RM_D>,
00267           BSUtilities::Rational<RT_N, RT_D>,
00268             BSUtilities::Rational<RE_N, RE_D>,
00269               BSUtilities::Rational<RTE_N, RTE_D>,
00270                 BSUtilities::Rational<RA_N, RA_D>,
00271                   BSUtilities::Rational<RLU_N, RLU_D> >,
00272                                      BT1, UL1, DU1, ST>, SU1> &quantity)
00273       {if (_rl_n == RL_N/BSUtilities::Gcd<RL_N, RL_D>::RET
00274          && _rl_d == RL_D/BSUtilities::Gcd<RL_N, RL_D>::RET
00275          && _rm_n == RM_N/BSUtilities::Gcd<RM_N, RM_D>::RET
00276          && _rm_d == RM_D/BSUtilities::Gcd<RM_N, RM_D>::RET
00277          && _rt_n == RT_N/BSUtilities::Gcd<RT_N, RT_D>::RET
00278          && _rt_d == RT_D/BSUtilities::Gcd<RT_N, RT_D>::RET
00279          && _re_n == RE_N/BSUtilities::Gcd<RE_N, RE_D>::RET
00280          && _re_d == RE_D/BSUtilities::Gcd<RE_N, RE_D>::RET
00281          && _rte_n == RTE_N/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00282          && _rte_d == RTE_D/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00283          && _ra_n == RA_N/BSUtilities::Gcd<RA_N, RA_D>::RET
00284          && _ra_d == RA_D/BSUtilities::Gcd<RA_N, RA_D>::RET
00285          && _rlu_n == RLU_N/BSUtilities::Gcd<RLU_N, RLU_D>::RET
00286          && _rlu_d == RLU_D/BSUtilities::Gcd<RLU_N, RLU_D>::RET)
00287 
00288          return value () != quantity.standard_value ();
00289 
00290          else
00291            {throw DimensionMismatch ();}
00292 
00293           }
00294 
00296 
00302   template<template<class, class> class Q1, class BT1, 
00303     long RL_N, long RL_D, long RM_N, long RM_D,
00304       long RT_N, long RT_D, long RE_N, long RE_D,
00305         long RTE_N, long RTE_D, long RA_N, long RA_D,
00306           long RLU_N, long RLU_D, class UL1, class DU1, class SU1>
00307     bool operator> (const Q1<Quantity<
00308       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
00309         BSUtilities::Rational<RM_N, RM_D>,
00310           BSUtilities::Rational<RT_N, RT_D>,
00311             BSUtilities::Rational<RE_N, RE_D>,
00312               BSUtilities::Rational<RTE_N, RTE_D>,
00313                 BSUtilities::Rational<RA_N, RA_D>,
00314                   BSUtilities::Rational<RLU_N, RLU_D> >,
00315                                      BT1, UL1, DU1, ST>, SU1> &quantity)
00316       {if (_rl_n == RL_N/BSUtilities::Gcd<RL_N, RL_D>::RET
00317          && _rl_d == RL_D/BSUtilities::Gcd<RL_N, RL_D>::RET
00318          && _rm_n == RM_N/BSUtilities::Gcd<RM_N, RM_D>::RET
00319          && _rm_d == RM_D/BSUtilities::Gcd<RM_N, RM_D>::RET
00320          && _rt_n == RT_N/BSUtilities::Gcd<RT_N, RT_D>::RET
00321          && _rt_d == RT_D/BSUtilities::Gcd<RT_N, RT_D>::RET
00322          && _re_n == RE_N/BSUtilities::Gcd<RE_N, RE_D>::RET
00323          && _re_d == RE_D/BSUtilities::Gcd<RE_N, RE_D>::RET
00324          && _rte_n == RTE_N/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00325          && _rte_d == RTE_D/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00326          && _ra_n == RA_N/BSUtilities::Gcd<RA_N, RA_D>::RET
00327          && _ra_d == RA_D/BSUtilities::Gcd<RA_N, RA_D>::RET
00328          && _rlu_n == RLU_N/BSUtilities::Gcd<RLU_N, RLU_D>::RET
00329          && _rlu_d == RLU_D/BSUtilities::Gcd<RLU_N, RLU_D>::RET)
00330 
00331          return value () > quantity.standard_value ();
00332 
00333          else
00334            {throw DimensionMismatch ();}
00335 
00336           }
00337 
00339 
00345   template<template<class, class> class Q1, class BT1, 
00346     long RL_N, long RL_D, long RM_N, long RM_D,
00347       long RT_N, long RT_D, long RE_N, long RE_D,
00348         long RTE_N, long RTE_D, long RA_N, long RA_D,
00349           long RLU_N, long RLU_D, class UL1, class DU1, class SU1>
00350     bool operator< (const Q1<Quantity<
00351       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
00352         BSUtilities::Rational<RM_N, RM_D>,
00353           BSUtilities::Rational<RT_N, RT_D>,
00354             BSUtilities::Rational<RE_N, RE_D>,
00355               BSUtilities::Rational<RTE_N, RTE_D>,
00356                 BSUtilities::Rational<RA_N, RA_D>,
00357                   BSUtilities::Rational<RLU_N, RLU_D> >,
00358                                      BT1, UL1, DU1, ST>, SU1> &quantity)
00359       {if (_rl_n == RL_N/BSUtilities::Gcd<RL_N, RL_D>::RET
00360          && _rl_d == RL_D/BSUtilities::Gcd<RL_N, RL_D>::RET
00361          && _rm_n == RM_N/BSUtilities::Gcd<RM_N, RM_D>::RET
00362          && _rm_d == RM_D/BSUtilities::Gcd<RM_N, RM_D>::RET
00363          && _rt_n == RT_N/BSUtilities::Gcd<RT_N, RT_D>::RET
00364          && _rt_d == RT_D/BSUtilities::Gcd<RT_N, RT_D>::RET
00365          && _re_n == RE_N/BSUtilities::Gcd<RE_N, RE_D>::RET
00366          && _re_d == RE_D/BSUtilities::Gcd<RE_N, RE_D>::RET
00367          && _rte_n == RTE_N/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00368          && _rte_d == RTE_D/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00369          && _ra_n == RA_N/BSUtilities::Gcd<RA_N, RA_D>::RET
00370          && _ra_d == RA_D/BSUtilities::Gcd<RA_N, RA_D>::RET
00371          && _rlu_n == RLU_N/BSUtilities::Gcd<RLU_N, RLU_D>::RET
00372          && _rlu_d == RLU_D/BSUtilities::Gcd<RLU_N, RLU_D>::RET)
00373 
00374          return value () < quantity.standard_value ();
00375 
00376          else
00377            {throw DimensionMismatch ();}
00378 
00379           }
00380 
00382 
00388   template<template<class, class> class Q1, class BT1, 
00389     long RL_N, long RL_D, long RM_N, long RM_D,
00390       long RT_N, long RT_D, long RE_N, long RE_D,
00391         long RTE_N, long RTE_D, long RA_N, long RA_D,
00392           long RLU_N, long RLU_D, class UL1, class DU1, class SU1>
00393     bool operator>= (const Q1<Quantity<
00394       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
00395         BSUtilities::Rational<RM_N, RM_D>,
00396           BSUtilities::Rational<RT_N, RT_D>,
00397             BSUtilities::Rational<RE_N, RE_D>,
00398               BSUtilities::Rational<RTE_N, RTE_D>,
00399                 BSUtilities::Rational<RA_N, RA_D>,
00400                   BSUtilities::Rational<RLU_N, RLU_D> >,
00401                                      BT1, UL1, DU1, ST>, SU1> &quantity)
00402       {if (_rl_n == RL_N/BSUtilities::Gcd<RL_N, RL_D>::RET
00403          && _rl_d == RL_D/BSUtilities::Gcd<RL_N, RL_D>::RET
00404          && _rm_n == RM_N/BSUtilities::Gcd<RM_N, RM_D>::RET
00405          && _rm_d == RM_D/BSUtilities::Gcd<RM_N, RM_D>::RET
00406          && _rt_n == RT_N/BSUtilities::Gcd<RT_N, RT_D>::RET
00407          && _rt_d == RT_D/BSUtilities::Gcd<RT_N, RT_D>::RET
00408          && _re_n == RE_N/BSUtilities::Gcd<RE_N, RE_D>::RET
00409          && _re_d == RE_D/BSUtilities::Gcd<RE_N, RE_D>::RET
00410          && _rte_n == RTE_N/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00411          && _rte_d == RTE_D/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00412          && _ra_n == RA_N/BSUtilities::Gcd<RA_N, RA_D>::RET
00413          && _ra_d == RA_D/BSUtilities::Gcd<RA_N, RA_D>::RET
00414          && _rlu_n == RLU_N/BSUtilities::Gcd<RLU_N, RLU_D>::RET
00415          && _rlu_d == RLU_D/BSUtilities::Gcd<RLU_N, RLU_D>::RET)
00416 
00417          return value () >= quantity.standard_value ();
00418 
00419          else
00420            {throw DimensionMismatch ();}
00421 
00422           }
00423 
00425 
00431   template<template<class, class> class Q1, class BT1, 
00432     long RL_N, long RL_D, long RM_N, long RM_D,
00433       long RT_N, long RT_D, long RE_N, long RE_D,
00434         long RTE_N, long RTE_D, long RA_N, long RA_D,
00435           long RLU_N, long RLU_D, class UL1, class DU1, class SU1>
00436     bool operator<= (const Q1<Quantity<
00437       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
00438         BSUtilities::Rational<RM_N, RM_D>,
00439           BSUtilities::Rational<RT_N, RT_D>,
00440             BSUtilities::Rational<RE_N, RE_D>,
00441               BSUtilities::Rational<RTE_N, RTE_D>,
00442                 BSUtilities::Rational<RA_N, RA_D>,
00443                   BSUtilities::Rational<RLU_N, RLU_D> >,
00444                                      BT1, UL1, DU1, ST>, SU1> &quantity)
00445       {if (_rl_n == RL_N/BSUtilities::Gcd<RL_N, RL_D>::RET
00446          && _rl_d == RL_D/BSUtilities::Gcd<RL_N, RL_D>::RET
00447          && _rm_n == RM_N/BSUtilities::Gcd<RM_N, RM_D>::RET
00448          && _rm_d == RM_D/BSUtilities::Gcd<RM_N, RM_D>::RET
00449          && _rt_n == RT_N/BSUtilities::Gcd<RT_N, RT_D>::RET
00450          && _rt_d == RT_D/BSUtilities::Gcd<RT_N, RT_D>::RET
00451          && _re_n == RE_N/BSUtilities::Gcd<RE_N, RE_D>::RET
00452          && _re_d == RE_D/BSUtilities::Gcd<RE_N, RE_D>::RET
00453          && _rte_n == RTE_N/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00454          && _rte_d == RTE_D/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00455          && _ra_n == RA_N/BSUtilities::Gcd<RA_N, RA_D>::RET
00456          && _ra_d == RA_D/BSUtilities::Gcd<RA_N, RA_D>::RET
00457          && _rlu_n == RLU_N/BSUtilities::Gcd<RLU_N, RLU_D>::RET
00458          && _rlu_d == RLU_D/BSUtilities::Gcd<RLU_N, RLU_D>::RET)
00459 
00460          return value () <= quantity.standard_value ();
00461 
00462          else
00463            {throw DimensionMismatch ();}
00464 
00465           }
00466 
00468 
00471   template<template<class, class> class Q1, class BT1, 
00472     long RL1_N, long RL1_D, long RM1_N, long RM1_D,
00473       long RT1_N, long RT1_D, long RE1_N, long RE1_D,
00474         long RTE1_N, long RTE1_D, long RA1_N, long RA1_D,
00475           long RLU1_N, long RLU1_D, class UL1, class DU1, class SU1>
00476     friend Dynamic<ST> pow (const Q1<Quantity<
00477       dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
00478         BSUtilities::Rational<RM1_N, RM1_D>,
00479           BSUtilities::Rational<RT1_N, RT1_D>,
00480             BSUtilities::Rational<RE1_N, RE1_D>,
00481               BSUtilities::Rational<RTE1_N, RTE1_D>,
00482                 BSUtilities::Rational<RA1_N, RA1_D>,
00483                   BSUtilities::Rational<RLU1_N, RLU1_D> >,
00484                      BT1, UL1, DU1, ST>, SU1> &quantity, const int &exp)
00485       {
00486         return 
00487           Dynamic<ST> (RL1_N * exp, RL1_D, RM1_N * exp, RM1_D,
00488             RT1_N * exp, RT1_D, RE1_N * exp, RE1_D, 
00489               RTE1_N * exp, RTE1_D, RA1_N * exp, RA1_D, 
00490                 RLU1_N * exp, RLU1_D,
00491                          ST(std::pow(quantity.standard_value (), exp)));
00492       }
00493 
00495 
00500   template<template<class, class> class Q1, class BT1, 
00501     long RL1_N, long RL1_D, long RM1_N, long RM1_D,
00502       long RT1_N, long RT1_D, long RE1_N, long RE1_D,
00503         long RTE1_N, long RTE1_D, long RA1_N, long RA1_D,
00504           long RLU1_N, long RLU1_D, class UL1, class DU1, class SU1>
00505     friend Dynamic<ST> pow (const Q1<Quantity<
00506       dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
00507         BSUtilities::Rational<RM1_N, RM1_D>,
00508           BSUtilities::Rational<RT1_N, RT1_D>,
00509             BSUtilities::Rational<RE1_N, RE1_D>,
00510               BSUtilities::Rational<RTE1_N, RTE1_D>,
00511                 BSUtilities::Rational<RA1_N, RA1_D>,
00512                   BSUtilities::Rational<RLU1_N, RLU1_D> >,
00513                      BT1, UL1, DU1, ST>, SU1> &quantity, 
00514                                                    const long int &exp)
00515       {
00516         return 
00517           Dynamic<ST> (RL1_N * exp, RL1_D, RM1_N * exp, RM1_D,
00518             RT1_N * exp, RT1_D, RE1_N * exp, RE1_D, 
00519               RTE1_N * exp, RTE1_D, RA1_N * exp, RA1_D, 
00520                 RLU1_N * exp, RLU1_D,
00521                   ST(std::pow(quantity.standard_value (), 
00522                                                         double (exp))));
00523       }
00524 
00526 
00530   template<template<class, class> class Q1, class BT1, 
00531     long RL1_N, long RL1_D, long RM1_N, long RM1_D,
00532       long RT1_N, long RT1_D, long RE1_N, long RE1_D,
00533         long RTE1_N, long RTE1_D, long RA1_N, long RA1_D,
00534           long RLU1_N, long RLU1_D, class UL1, class DU1, class SU1>
00535     friend Dynamic<ST> pow (const Q1<Quantity<
00536       dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
00537         BSUtilities::Rational<RM1_N, RM1_D>,
00538           BSUtilities::Rational<RT1_N, RT1_D>,
00539             BSUtilities::Rational<RE1_N, RE1_D>,
00540               BSUtilities::Rational<RTE1_N, RTE1_D>,
00541                 BSUtilities::Rational<RA1_N, RA1_D>,
00542                   BSUtilities::Rational<RLU1_N, RLU1_D> >,
00543                     BT1, UL1, DU1, ST>, SU1> &quantity, 
00544                                                       const double &exp)
00545       {
00546         std::pair<long, long> rational = BSUtilities::contFrac (exp);
00547         return 
00548           Dynamic<ST> 
00549             (RL1_N * rational.first, RL1_D * rational.second,
00550               RM1_N * rational.first, RM1_D * rational.second,
00551                 RT1_N * rational.first, RT1_D * rational.second, 
00552                   RE1_N * rational.first, RE1_D * rational.second, 
00553                     RTE1_N * rational.first, RTE1_D * rational.second, 
00554                       RA1_N * rational.first, RA1_D * rational.second, 
00555                         RLU1_N * rational.first, 
00556                                                RLU1_D * rational.second,
00557                           ST(std::pow(quantity.standard_value (), 
00558                                                                  exp)));
00559       }
00560   };
00561 
00562 }
00563 
00564 #endif /* _Dynamic_h */