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 
00083       Dynamic 
00084         (const long rl_n, const long rl_d, 
00085           const long rm_n, const long rm_d,
00086             const long rt_n, const long rt_d,
00087               const long re_n, const long re_d,
00088                 const long rte_n, const long rte_d,
00089                   const long ra_n, const long ra_d,
00090                      const long rlu_n, const long rlu_d, const ST value)
00091         : _value (value), 
00092            _rl_n (rl_n/BSUtilities::gcd(rl_n, rl_d)), 
00093             _rl_d (rl_d/BSUtilities::gcd(rl_n, rl_d)), 
00094              _rm_n (rm_n/BSUtilities::gcd(rm_n, rm_d)), 
00095               _rm_d (rm_d/BSUtilities::gcd(rm_n, rm_d)),
00096                _rt_n (rt_n/BSUtilities::gcd(rt_n, rt_d)), 
00097                 _rt_d (rt_d/BSUtilities::gcd(rt_n, rt_d)), 
00098                  _re_n (re_n/BSUtilities::gcd(re_n, re_d)), 
00099                   _re_d (re_d/BSUtilities::gcd(re_n, re_d)),
00100                    _rte_n (rte_n/BSUtilities::gcd(rte_n, rte_d)), 
00101                     _rte_d (rte_d/BSUtilities::gcd(rte_n, rte_d)), 
00102                      _ra_n (ra_n/BSUtilities::gcd(ra_n, ra_d)), 
00103                       _ra_d (ra_d/BSUtilities::gcd(ra_n, ra_d)),
00104                        _rlu_n (rlu_n/BSUtilities::gcd(rlu_n, rlu_d)), 
00105                         _rlu_d (rlu_d/BSUtilities::gcd(rlu_n, rlu_d)) {}
00106 
00107     public:
00109       Dynamic (const Dynamic &dynamic)
00110         : _value (dynamic._value),
00111             _rl_n (dynamic._rl_n), _rl_d (dynamic._rl_d), 
00112               _rm_n (dynamic._rm_n), _rm_d (dynamic._rm_d),
00113                 _rt_n (dynamic._rt_n), _rt_d (dynamic._rt_d), 
00114                   _re_n (dynamic._re_n), _re_d (dynamic._re_d),
00115                     _rte_n (dynamic._rte_n), _rte_d (dynamic._rte_d),
00116                       _ra_n (dynamic._ra_n), _ra_d (dynamic._ra_d),
00117                         _rlu_n (dynamic._rlu_n), _rlu_d (dynamic._rlu_d)
00118                                                                       {}
00119 
00121       void operator= (const Dynamic &dynamic)
00122         {_rl_n = dynamic._rl_n; 
00123          _rl_d = dynamic._rl_d; 
00124          _rm_n = dynamic._rm_n; 
00125          _rm_d = dynamic._rm_d;
00126          _rt_n = dynamic._rt_n; 
00127          _rt_d = dynamic._rt_d; 
00128          _re_n = dynamic._re_n; 
00129          _re_d = dynamic._re_d;
00130          _rte_n = dynamic._rte_n; 
00131          _rte_d = dynamic._rte_d;
00132          _ra_n = dynamic._ra_n; 
00133          _ra_d = dynamic._ra_d;
00134          _rlu_n = dynamic._rlu_n; 
00135          _rlu_d = dynamic._rlu_d; 
00136          _value = dynamic._value;
00137         }
00138 
00140     ST value (void) const {return _value;}
00141 
00143 
00145     Dynamic operator*= (const ST factor) 
00146                                        {_value *= factor; return *this;}
00147 
00148 //* operator* for right hand side multiplication with an ST
00152     Dynamic operator* (const ST factor) 
00153                                      {return Dynamic (*this) *= factor;}
00154 
00156 
00158     Dynamic operator/= (const ST divisor) 
00159                                       {_value /= divisor; return *this;}
00160 
00161 //* operator/ for right hand side division by an ST
00165     Dynamic operator/ (const ST divisor) 
00166                                     {return Dynamic (*this) /= divisor;}
00167 
00169 
00171     Dynamic operator+ (void) const {return Dynamic (*this);}
00172 
00174 
00177     Dynamic operator- (void) const 
00178                                   {return Dynamic (*this) *= ST (-1.0);}
00179 
00181 
00187   template<template<class, class> class Q1, class BT1, 
00188     long RL_N, long RL_D, long RM_N, long RM_D,
00189       long RT_N, long RT_D, long RE_N, long RE_D,
00190         long RTE_N, long RTE_D, long RA_N, long RA_D,
00191           long RLU_N, long RLU_D, class UL1, class DU1, class SU1>
00192     bool operator== (const Q1<Quantity<
00193       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
00194         BSUtilities::Rational<RM_N, RM_D>,
00195           BSUtilities::Rational<RT_N, RT_D>,
00196             BSUtilities::Rational<RE_N, RE_D>,
00197               BSUtilities::Rational<RTE_N, RTE_D>,
00198                 BSUtilities::Rational<RA_N, RA_D>,
00199                   BSUtilities::Rational<RLU_N, RLU_D> >,
00200                                      BT1, UL1, DU1, ST>, SU1> &quantity)
00201       {if (_rl_n == RL_N/BSUtilities::Gcd<RL_N, RL_D>::RET
00202          && _rl_d == RL_D/BSUtilities::Gcd<RL_N, RL_D>::RET
00203          && _rm_n == RM_N/BSUtilities::Gcd<RM_N, RM_D>::RET
00204          && _rm_d == RM_D/BSUtilities::Gcd<RM_N, RM_D>::RET
00205          && _rt_n == RT_N/BSUtilities::Gcd<RT_N, RT_D>::RET
00206          && _rt_d == RT_D/BSUtilities::Gcd<RT_N, RT_D>::RET
00207          && _re_n == RE_N/BSUtilities::Gcd<RE_N, RE_D>::RET
00208          && _re_d == RE_D/BSUtilities::Gcd<RE_N, RE_D>::RET
00209          && _rte_n == RTE_N/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00210          && _rte_d == RTE_D/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00211          && _ra_n == RA_N/BSUtilities::Gcd<RA_N, RA_D>::RET
00212          && _ra_d == RA_D/BSUtilities::Gcd<RA_N, RA_D>::RET
00213          && _rlu_n == RLU_N/BSUtilities::Gcd<RLU_N, RLU_D>::RET
00214          && _rlu_d == RLU_D/BSUtilities::Gcd<RLU_N, RLU_D>::RET)
00215 
00216          return value () == quantity.standard_value ();
00217 
00218          else
00219            {throw DimensionMismatch ();}
00220 
00221           }
00222 
00224 
00230     bool operator== (Dynamic<ST> quantity)
00231       {if (_rl_n == quantity._rl_n
00232          && _rl_d == quantity._rl_d
00233          && _rm_n == quantity._rm_n
00234          && _rm_d == quantity._rm_d
00235          && _rt_n == quantity._rt_n
00236          && _rt_d == quantity._rt_d
00237          && _re_n == quantity._re_n
00238          && _re_d == quantity._re_d 
00239          && _rte_n == quantity._rte_n 
00240          && _rte_d == quantity._rte_d
00241          && _ra_n == quantity._ra_n
00242          && _ra_d == quantity._ra_d
00243          && _rlu_n == quantity._rlu_n
00244          && _rlu_d == quantity._rlu_d)
00245 
00246          return value () == quantity.value ();
00247 
00248          else
00249            {throw DimensionMismatch ();}
00250 
00251           }
00252 
00254 
00260   template<template<class, class> class Q1, class BT1, 
00261     long RL_N, long RL_D, long RM_N, long RM_D,
00262       long RT_N, long RT_D, long RE_N, long RE_D,
00263         long RTE_N, long RTE_D, long RA_N, long RA_D,
00264           long RLU_N, long RLU_D, class UL1, class DU1, class SU1>
00265     bool operator!= (const Q1<Quantity<
00266       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
00267         BSUtilities::Rational<RM_N, RM_D>,
00268           BSUtilities::Rational<RT_N, RT_D>,
00269             BSUtilities::Rational<RE_N, RE_D>,
00270               BSUtilities::Rational<RTE_N, RTE_D>,
00271                 BSUtilities::Rational<RA_N, RA_D>,
00272                   BSUtilities::Rational<RLU_N, RLU_D> >,
00273                                      BT1, UL1, DU1, ST>, SU1> &quantity)
00274       {if (_rl_n == RL_N/BSUtilities::Gcd<RL_N, RL_D>::RET
00275          && _rl_d == RL_D/BSUtilities::Gcd<RL_N, RL_D>::RET
00276          && _rm_n == RM_N/BSUtilities::Gcd<RM_N, RM_D>::RET
00277          && _rm_d == RM_D/BSUtilities::Gcd<RM_N, RM_D>::RET
00278          && _rt_n == RT_N/BSUtilities::Gcd<RT_N, RT_D>::RET
00279          && _rt_d == RT_D/BSUtilities::Gcd<RT_N, RT_D>::RET
00280          && _re_n == RE_N/BSUtilities::Gcd<RE_N, RE_D>::RET
00281          && _re_d == RE_D/BSUtilities::Gcd<RE_N, RE_D>::RET
00282          && _rte_n == RTE_N/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00283          && _rte_d == RTE_D/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00284          && _ra_n == RA_N/BSUtilities::Gcd<RA_N, RA_D>::RET
00285          && _ra_d == RA_D/BSUtilities::Gcd<RA_N, RA_D>::RET
00286          && _rlu_n == RLU_N/BSUtilities::Gcd<RLU_N, RLU_D>::RET
00287          && _rlu_d == RLU_D/BSUtilities::Gcd<RLU_N, RLU_D>::RET)
00288 
00289          return value () != quantity.standard_value ();
00290 
00291          else
00292            {throw DimensionMismatch ();}
00293 
00294           }
00295 
00297 
00303   template<template<class, class> class Q1, class BT1, 
00304     long RL_N, long RL_D, long RM_N, long RM_D,
00305       long RT_N, long RT_D, long RE_N, long RE_D,
00306         long RTE_N, long RTE_D, long RA_N, long RA_D,
00307           long RLU_N, long RLU_D, class UL1, class DU1, class SU1>
00308     bool operator> (const Q1<Quantity<
00309       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
00310         BSUtilities::Rational<RM_N, RM_D>,
00311           BSUtilities::Rational<RT_N, RT_D>,
00312             BSUtilities::Rational<RE_N, RE_D>,
00313               BSUtilities::Rational<RTE_N, RTE_D>,
00314                 BSUtilities::Rational<RA_N, RA_D>,
00315                   BSUtilities::Rational<RLU_N, RLU_D> >,
00316                                      BT1, UL1, DU1, ST>, SU1> &quantity)
00317       {if (_rl_n == RL_N/BSUtilities::Gcd<RL_N, RL_D>::RET
00318          && _rl_d == RL_D/BSUtilities::Gcd<RL_N, RL_D>::RET
00319          && _rm_n == RM_N/BSUtilities::Gcd<RM_N, RM_D>::RET
00320          && _rm_d == RM_D/BSUtilities::Gcd<RM_N, RM_D>::RET
00321          && _rt_n == RT_N/BSUtilities::Gcd<RT_N, RT_D>::RET
00322          && _rt_d == RT_D/BSUtilities::Gcd<RT_N, RT_D>::RET
00323          && _re_n == RE_N/BSUtilities::Gcd<RE_N, RE_D>::RET
00324          && _re_d == RE_D/BSUtilities::Gcd<RE_N, RE_D>::RET
00325          && _rte_n == RTE_N/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00326          && _rte_d == RTE_D/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00327          && _ra_n == RA_N/BSUtilities::Gcd<RA_N, RA_D>::RET
00328          && _ra_d == RA_D/BSUtilities::Gcd<RA_N, RA_D>::RET
00329          && _rlu_n == RLU_N/BSUtilities::Gcd<RLU_N, RLU_D>::RET
00330          && _rlu_d == RLU_D/BSUtilities::Gcd<RLU_N, RLU_D>::RET)
00331 
00332          return value () > quantity.standard_value ();
00333 
00334          else
00335            {throw DimensionMismatch ();}
00336 
00337           }
00338 
00340 
00346   template<template<class, class> class Q1, class BT1, 
00347     long RL_N, long RL_D, long RM_N, long RM_D,
00348       long RT_N, long RT_D, long RE_N, long RE_D,
00349         long RTE_N, long RTE_D, long RA_N, long RA_D,
00350           long RLU_N, long RLU_D, class UL1, class DU1, class SU1>
00351     bool operator< (const Q1<Quantity<
00352       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
00353         BSUtilities::Rational<RM_N, RM_D>,
00354           BSUtilities::Rational<RT_N, RT_D>,
00355             BSUtilities::Rational<RE_N, RE_D>,
00356               BSUtilities::Rational<RTE_N, RTE_D>,
00357                 BSUtilities::Rational<RA_N, RA_D>,
00358                   BSUtilities::Rational<RLU_N, RLU_D> >,
00359                                      BT1, UL1, DU1, ST>, SU1> &quantity)
00360       {if (_rl_n == RL_N/BSUtilities::Gcd<RL_N, RL_D>::RET
00361          && _rl_d == RL_D/BSUtilities::Gcd<RL_N, RL_D>::RET
00362          && _rm_n == RM_N/BSUtilities::Gcd<RM_N, RM_D>::RET
00363          && _rm_d == RM_D/BSUtilities::Gcd<RM_N, RM_D>::RET
00364          && _rt_n == RT_N/BSUtilities::Gcd<RT_N, RT_D>::RET
00365          && _rt_d == RT_D/BSUtilities::Gcd<RT_N, RT_D>::RET
00366          && _re_n == RE_N/BSUtilities::Gcd<RE_N, RE_D>::RET
00367          && _re_d == RE_D/BSUtilities::Gcd<RE_N, RE_D>::RET
00368          && _rte_n == RTE_N/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00369          && _rte_d == RTE_D/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00370          && _ra_n == RA_N/BSUtilities::Gcd<RA_N, RA_D>::RET
00371          && _ra_d == RA_D/BSUtilities::Gcd<RA_N, RA_D>::RET
00372          && _rlu_n == RLU_N/BSUtilities::Gcd<RLU_N, RLU_D>::RET
00373          && _rlu_d == RLU_D/BSUtilities::Gcd<RLU_N, RLU_D>::RET)
00374 
00375          return value () < quantity.standard_value ();
00376 
00377          else
00378            {throw DimensionMismatch ();}
00379 
00380           }
00381 
00383 
00389   template<template<class, class> class Q1, class BT1, 
00390     long RL_N, long RL_D, long RM_N, long RM_D,
00391       long RT_N, long RT_D, long RE_N, long RE_D,
00392         long RTE_N, long RTE_D, long RA_N, long RA_D,
00393           long RLU_N, long RLU_D, class UL1, class DU1, class SU1>
00394     bool operator>= (const Q1<Quantity<
00395       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
00396         BSUtilities::Rational<RM_N, RM_D>,
00397           BSUtilities::Rational<RT_N, RT_D>,
00398             BSUtilities::Rational<RE_N, RE_D>,
00399               BSUtilities::Rational<RTE_N, RTE_D>,
00400                 BSUtilities::Rational<RA_N, RA_D>,
00401                   BSUtilities::Rational<RLU_N, RLU_D> >,
00402                                      BT1, UL1, DU1, ST>, SU1> &quantity)
00403       {if (_rl_n == RL_N/BSUtilities::Gcd<RL_N, RL_D>::RET
00404          && _rl_d == RL_D/BSUtilities::Gcd<RL_N, RL_D>::RET
00405          && _rm_n == RM_N/BSUtilities::Gcd<RM_N, RM_D>::RET
00406          && _rm_d == RM_D/BSUtilities::Gcd<RM_N, RM_D>::RET
00407          && _rt_n == RT_N/BSUtilities::Gcd<RT_N, RT_D>::RET
00408          && _rt_d == RT_D/BSUtilities::Gcd<RT_N, RT_D>::RET
00409          && _re_n == RE_N/BSUtilities::Gcd<RE_N, RE_D>::RET
00410          && _re_d == RE_D/BSUtilities::Gcd<RE_N, RE_D>::RET
00411          && _rte_n == RTE_N/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00412          && _rte_d == RTE_D/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00413          && _ra_n == RA_N/BSUtilities::Gcd<RA_N, RA_D>::RET
00414          && _ra_d == RA_D/BSUtilities::Gcd<RA_N, RA_D>::RET
00415          && _rlu_n == RLU_N/BSUtilities::Gcd<RLU_N, RLU_D>::RET
00416          && _rlu_d == RLU_D/BSUtilities::Gcd<RLU_N, RLU_D>::RET)
00417 
00418          return value () >= quantity.standard_value ();
00419 
00420          else
00421            {throw DimensionMismatch ();}
00422 
00423           }
00424 
00426 
00432   template<template<class, class> class Q1, class BT1, 
00433     long RL_N, long RL_D, long RM_N, long RM_D,
00434       long RT_N, long RT_D, long RE_N, long RE_D,
00435         long RTE_N, long RTE_D, long RA_N, long RA_D,
00436           long RLU_N, long RLU_D, class UL1, class DU1, class SU1>
00437     bool operator<= (const Q1<Quantity<
00438       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
00439         BSUtilities::Rational<RM_N, RM_D>,
00440           BSUtilities::Rational<RT_N, RT_D>,
00441             BSUtilities::Rational<RE_N, RE_D>,
00442               BSUtilities::Rational<RTE_N, RTE_D>,
00443                 BSUtilities::Rational<RA_N, RA_D>,
00444                   BSUtilities::Rational<RLU_N, RLU_D> >,
00445                                      BT1, UL1, DU1, ST>, SU1> &quantity)
00446       {if (_rl_n == RL_N/BSUtilities::Gcd<RL_N, RL_D>::RET
00447          && _rl_d == RL_D/BSUtilities::Gcd<RL_N, RL_D>::RET
00448          && _rm_n == RM_N/BSUtilities::Gcd<RM_N, RM_D>::RET
00449          && _rm_d == RM_D/BSUtilities::Gcd<RM_N, RM_D>::RET
00450          && _rt_n == RT_N/BSUtilities::Gcd<RT_N, RT_D>::RET
00451          && _rt_d == RT_D/BSUtilities::Gcd<RT_N, RT_D>::RET
00452          && _re_n == RE_N/BSUtilities::Gcd<RE_N, RE_D>::RET
00453          && _re_d == RE_D/BSUtilities::Gcd<RE_N, RE_D>::RET
00454          && _rte_n == RTE_N/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00455          && _rte_d == RTE_D/BSUtilities::Gcd<RTE_N, RTE_D>::RET
00456          && _ra_n == RA_N/BSUtilities::Gcd<RA_N, RA_D>::RET
00457          && _ra_d == RA_D/BSUtilities::Gcd<RA_N, RA_D>::RET
00458          && _rlu_n == RLU_N/BSUtilities::Gcd<RLU_N, RLU_D>::RET
00459          && _rlu_d == RLU_D/BSUtilities::Gcd<RLU_N, RLU_D>::RET)
00460 
00461          return value () <= quantity.standard_value ();
00462 
00463          else
00464            {throw DimensionMismatch ();}
00465 
00466           }
00467 
00469 
00472   template<template<class, class, class> class Q1, class BT1, 
00473     long RL1_N, long RL1_D, long RM1_N, long RM1_D,
00474       long RT1_N, long RT1_D, long RE1_N, long RE1_D,
00475         long RTE1_N, long RTE1_D, long RA1_N, long RA1_D,
00476           long RLU1_N, long RLU1_D, class UL1, class DU1, class SU1, class DD1>
00477     static Dynamic<ST> pow (const Q1<Quantity<
00478       dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
00479         BSUtilities::Rational<RM1_N, RM1_D>,
00480           BSUtilities::Rational<RT1_N, RT1_D>,
00481             BSUtilities::Rational<RE1_N, RE1_D>,
00482               BSUtilities::Rational<RTE1_N, RTE1_D>,
00483                 BSUtilities::Rational<RA1_N, RA1_D>,
00484                   BSUtilities::Rational<RLU1_N, RLU1_D> >,
00485                      BT1, UL1, DU1, ST>, SU1, DD1> &quantity, const int &exp)
00486       {
00487         return 
00488           Dynamic<ST> (RL1_N * exp, RL1_D, RM1_N * exp, RM1_D,
00489             RT1_N * exp, RT1_D, RE1_N * exp, RE1_D, 
00490               RTE1_N * exp, RTE1_D, RA1_N * exp, RA1_D, 
00491                 RLU1_N * exp, RLU1_D,
00492                          ST(std::pow(quantity.standard_value (), exp)));
00493       }
00494 
00496 
00501   template<template<class, class, class> class Q1, class BT1, 
00502     long RL1_N, long RL1_D, long RM1_N, long RM1_D,
00503       long RT1_N, long RT1_D, long RE1_N, long RE1_D,
00504         long RTE1_N, long RTE1_D, long RA1_N, long RA1_D,
00505           long RLU1_N, long RLU1_D, class UL1, class DU1, class SU1, class DD1>
00506     static Dynamic<ST> pow (const Q1<Quantity<
00507       dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
00508         BSUtilities::Rational<RM1_N, RM1_D>,
00509           BSUtilities::Rational<RT1_N, RT1_D>,
00510             BSUtilities::Rational<RE1_N, RE1_D>,
00511               BSUtilities::Rational<RTE1_N, RTE1_D>,
00512                 BSUtilities::Rational<RA1_N, RA1_D>,
00513                   BSUtilities::Rational<RLU1_N, RLU1_D> >,
00514                      BT1, UL1, DU1, ST>, SU1, DD1> &quantity, 
00515                                                    const long int &exp)
00516       {
00517         return 
00518           Dynamic<ST> (RL1_N * exp, RL1_D, RM1_N * exp, RM1_D,
00519             RT1_N * exp, RT1_D, RE1_N * exp, RE1_D, 
00520               RTE1_N * exp, RTE1_D, RA1_N * exp, RA1_D, 
00521                 RLU1_N * exp, RLU1_D,
00522                   ST(std::pow(quantity.standard_value (), 
00523                                                         double (exp))));
00524       }
00525 
00527 
00531   template<template<class, class, class> class Q1, class BT1, 
00532     long RL1_N, long RL1_D, long RM1_N, long RM1_D,
00533       long RT1_N, long RT1_D, long RE1_N, long RE1_D,
00534         long RTE1_N, long RTE1_D, long RA1_N, long RA1_D,
00535           long RLU1_N, long RLU1_D, class UL1, class DU1, class SU1, class DD1>
00536     static Dynamic<ST> pow (const Q1<Quantity<
00537       dimension::Dimension<BSUtilities::Rational<RL1_N, RL1_D>,
00538         BSUtilities::Rational<RM1_N, RM1_D>,
00539           BSUtilities::Rational<RT1_N, RT1_D>,
00540             BSUtilities::Rational<RE1_N, RE1_D>,
00541               BSUtilities::Rational<RTE1_N, RTE1_D>,
00542                 BSUtilities::Rational<RA1_N, RA1_D>,
00543                   BSUtilities::Rational<RLU1_N, RLU1_D> >,
00544                     BT1, UL1, DU1, ST>, SU1, DD1> &quantity, 
00545                                                       const double &exp)
00546       {
00547         std::pair<long, long> rational = BSUtilities::contFrac (exp);
00548         return 
00549           Dynamic<ST> 
00550             (RL1_N * rational.first, RL1_D * rational.second,
00551               RM1_N * rational.first, RM1_D * rational.second,
00552                 RT1_N * rational.first, RT1_D * rational.second, 
00553                   RE1_N * rational.first, RE1_D * rational.second, 
00554                     RTE1_N * rational.first, RTE1_D * rational.second, 
00555                       RA1_N * rational.first, RA1_D * rational.second, 
00556                         RLU1_N * rational.first, 
00557                                                RLU1_D * rational.second,
00558                           ST(std::pow(quantity.standard_value (), 
00559                                                                  exp)));
00560       }
00561   };
00562 
00563 } // end namespace quantity
00564 
00565 #endif /* _Dynamic_h */