Quantity: Quantity.h Source File

00001 
00005 /* Copyright (C) 2002 - 2006, 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 _Quantity_h
00025 #define _Quantity_h
00026 
00027 #include "Quantity/Unit.h"
00028 #include "Quantity/Dimension.h"
00029 #include "Quantity/QuantityError.h"
00030 
00031 #include "BSUtilities.h"
00032 #include "Conversion.h"
00033 
00034 #include "Singleton.h"
00035 #include "NullType.h"
00036 
00037 #include <iostream>
00038 #include <string>
00039 
00041 namespace quantity {
00042 
00044 //
00045 //  Helper classes and structs which store and/or check 
00046 //  specific units or lists of units.
00047 //
00049 
00051 
00060 template<class UT, class UL>
00061   class UnitPointerBySymbol
00062   {
00063     public:
00065       static unit::Unit<UT> *result (const std::string &symbol)
00066         {if (UL::Head::Symbol () == symbol)
00067            return new typename UL::Head;
00068          else
00069            return UnitPointerBySymbol<UT, typename UL::Tail>::result 
00070                                                                (symbol);
00071         }
00072   };
00073 
00075 
00079 template<class UT>
00080   class UnitPointerBySymbol<UT, Loki::NullType>
00081   {
00082     public:
00084 
00087       static unit::Unit<UT> *result (const std::string &)
00088         {throw UnitMismatch (); return 0;}
00089   };
00090 
00092 
00100 template<class UL>
00101   class UnitIndexBySymbol
00102   {
00103     public:
00104       static const int index (const std::string &symbol)
00105         {if (UL::Head::Symbol () == symbol)
00106            return 0;
00107          else
00108            return 
00109              UnitIndexBySymbol<typename UL::Tail>::index (symbol) + 1;
00110         }
00111   };
00112 
00114 
00118 template<>
00119   class UnitIndexBySymbol<Loki::NullType>
00120   {
00121     public:
00123 
00126       static int index (const std::string &)
00127         {throw UnitMismatch (); return -1;}
00128   };
00129 
00131 
00133 template<class UL>
00134   class ListUnitSymbols
00135   {
00136     public:
00138 
00142     static std::vector<std::string> & result 
00143                                 (std::vector<std::string> &stringvector)
00144       {
00145        stringvector.push_back (UL::Head::Symbol ());
00146        return ListUnitSymbols<typename UL::Tail>::result (stringvector);
00147       }
00148   };
00149 
00151 
00153 template<>
00154   class ListUnitSymbols<Loki::NullType>
00155   {
00156     public:
00158     static std::vector<std::string> & result 
00159                                 (std::vector<std::string> &stringvector)
00160       {
00161         return stringvector;
00162       }
00163   };
00164 
00171 template<class UT, class UL>
00172   class AllUnits
00173   {
00174     private:
00176 
00178       typedef 
00179            typename unit::CheckUnits<unit::Unit<UT>, UL>::Check Check;
00180 
00181     public:
00183       typedef UL Units;
00184 
00186 
00194       static ::unit::Unit<UT> *unit (const std::string &unitstring)
00195         {return UnitPointerBySymbol<UT, UL>::result (unitstring);}
00196 
00198 
00201       static std::vector<std::string> allsymbols (void)
00202         {std::vector<std::string> stringvector;
00203          return ListUnitSymbols<UL>::result (stringvector);
00204         }
00205   };
00206 
00208 
00211 template<class UT, class U>
00212   class DefaultUnit
00213   {
00214     private:
00216 
00218       typedef 
00219              typename unit::CheckUnit<unit::Unit<UT>, U>::Check Check;
00220 
00221     public:
00223       typedef U Unit;
00224   };
00225 
00227 template<class U, class TL> struct CheckAgainstAllUnits;
00228 
00230 
00238 template<class U, class Head, class Tail> 
00239   struct CheckAgainstAllUnits<U, Loki::Typelist<Head, Tail> >
00240   {
00241     typedef 
00242       typename BSUtilities::IF<BSUtilities::SameType<U, Head>::sameType,
00243               U, typename CheckAgainstAllUnits<U, Tail>::RET >::RET RET;
00244   };
00245 
00247 
00254 template<class U>
00255   struct CheckAgainstAllUnits<U, Loki::NullType>
00256   {
00257     typedef unit::UnitError<true> RET;
00258   };
00259   
00261 //
00262 //  Helper structs which handle dimensions
00263 //
00265 
00267 
00269 template<bool>
00270   struct DimensionError;
00271 
00273 
00277 template<>
00278   struct DimensionError<false>
00279     {
00281 
00283        static const bool RET = true;
00284     };
00285 
00287 
00291 template<class Q>
00292   struct CheckDimensionality
00293   {
00294     public: 
00296 
00298       static const bool RET =
00299         BSUtilities::IF<Q::Dim::IsDimensionless, DimensionError<false>, 
00300                                        DimensionError<true> >::RET::RET;
00301   };
00302 
00304 //
00305 //  helper classes for input and output
00306 //
00308 
00310 
00312 template<bool P> class PrintName;
00314 
00316 template<bool P> class PrintSymbol;
00317 
00319 class PrintStatus
00320   {
00321     private:
00323       static bool _name;
00325       static bool _symbol;
00326 
00327     public:
00329 
00331       bool name (void) const {return _name;}
00333 
00335       bool symbol (void) const {return _symbol;}
00336 
00338       template<bool P> friend class PrintName;
00339 
00341       template<bool P> friend class PrintSymbol;
00342   };
00343 
00345 typedef Loki::SingletonHolder<PrintStatus> PrintStatusHolder;
00346 
00347 #define PS PrintStatusHolder::Instance()
00348 
00350 
00353 template<bool P>
00354   class PrintName
00355   {
00357 
00360     void set (bool name) const {PrintStatus::_name = name;}
00361 
00363 
00369     friend std::ostream & operator<< 
00370                               (std::ostream &os, const PrintName &print)
00371            {print.set (P); return os;}
00372   };
00373 
00375 
00378 template<bool P>
00379   class PrintSymbol
00380   {
00382 
00385     void set (bool symbol) const {PrintStatus::_symbol = symbol;}
00386 
00388 
00394     friend std::ostream & operator<< 
00395                            (std::ostream &os, const PrintSymbol &print)
00396            {print.set (P); return os;}
00397 
00398   };
00399 
00401 
00403 template<bool P> class ReadName;
00404 
00406 
00408 template<bool P> class ReadSymbol;
00409 
00411 
00413 template<bool P> class ReadEqual;
00414 
00416 class ReadStatus
00417   {
00418     private:
00420       static bool _name;
00421 
00423       static bool _symbol;
00424 
00426       static bool _equal;
00427 
00429 
00432       static std::string _unit;
00433 
00434     public:
00436 
00438       bool name (void) const {return _name;}
00439 
00441 
00443       bool symbol (void) const {return _symbol;}
00444 
00446 
00448       bool equal (void) const {return _equal;}
00449 
00451 
00453       std::string unit (void) const {return _unit;}
00454 
00456       template<bool P> friend class ReadName;
00457 
00459       template<bool P> friend class ReadSymbol;
00460 
00462       template<bool P> friend class ReadEqual;
00463 
00465       template<class U> friend class ReadUnit;
00466   };
00467 
00469 typedef Loki::SingletonHolder<ReadStatus> ReadStatusHolder;
00470 
00471 #define RS ReadStatusHolder::Instance()
00472 
00474 
00477 template<bool P>
00478   class ReadName
00479   {
00481 
00484     void set (bool name) const {ReadStatus::_name = name;}
00485 
00487 
00493     friend std::istream & operator>> 
00494                               (std::istream &is, const ReadName &read)
00495            {read.set (P); return is;}
00496   };
00497 
00499 
00502 template<bool P>
00503   class ReadSymbol
00504   {
00506 
00509     void set (bool symbol) const {ReadStatus::_symbol = symbol;}
00510 
00512 
00518     friend std::istream & operator>> 
00519                            (std::istream &is, const ReadSymbol &read)
00520            {read.set (P); return is;}
00521 
00522   };
00523 
00525 
00528 template<bool P>
00529   class ReadEqual
00530   {
00532 
00535     void set (bool equal) const {ReadStatus::_equal = equal;}
00536 
00538 
00544     friend std::istream & operator>> 
00545                               (std::istream &is, const ReadEqual &read)
00546            {read.set (P); return is;}
00547 
00548   };
00549 
00551 
00553 template<class U>
00554   class ReadUnit
00555   {
00557 
00560     void set (std::string unit) const {ReadStatus::_unit = unit;}
00561 
00563 
00570     friend std::istream & operator>> 
00571                            (std::istream &is, const ReadUnit<U> &unit)
00572            {unit.set (U::Symbol ()); return is;}
00573 
00574   };
00575 
00576 typedef Loki::NullType NoUnit;
00577 
00579 
00581 template<>
00582   class ReadUnit<NoUnit>
00583   {
00585 
00588     void set (std::string unit) const {ReadStatus::_unit = unit;}
00589 
00591 
00597     friend std::istream & operator>> 
00598                       (std::istream &is, const ReadUnit<NoUnit> &unit)
00599            {unit.set (""); return is;}
00600 
00601   };
00602 
00603 
00605 //
00606 //  the Quantities base class
00607 //
00609 
00611 
00613 class Quantities
00614   {
00615     public:
00617 
00620       static const std::string Version (void)
00621         {static const 
00622           std::string v_string ("Quantities version 1.1 with ");
00623              return v_string + ::unit::Units::Version () + ", " 
00624                    + ::dimension::Dimensions::Version () + 
00625                        " and " + ::BSUtilities::version ();}
00626 
00628 
00631       static const std::string version (void) {return Version ();}
00632 
00634 
00636       virtual const std::string unitsymbol (void) const = 0;
00637 
00639 
00641       virtual const std::string unitname (void) const = 0;
00642 
00644 
00646       virtual const bool isDimensionless (void) const = 0;
00647 
00649 
00652       virtual ~Quantities (void) {}
00653 
00654   };
00655 
00657 //
00658 //  the Quantity base class with helpers
00659 //
00661 
00663 
00667 template<class D, class UT, class UL, class DU, class ST = double> 
00668                                                          class Quantity;
00669 
00671 template <class Q> struct Name;
00672 
00674 template<class DIM, class UT, class UL, class DU, class ST>
00675   struct Name<Quantity<DIM, UT, UL, DU, ST> >
00676   {
00678 
00680     static const std::string String;
00681   };
00682 
00684 template <class Q> struct Symbol;
00685 
00687 template<class DIM, class UT, class UL, class DU, class ST>
00688   struct Symbol<Quantity<DIM, UT, UL, DU, ST> >
00689   {
00691 
00693     static const std::string String;
00694   };
00695 
00697 
00699   template<class U, class ST = double> struct Standard;
00700 
00702 
00706   template<class UT, class U, class ST>
00707     struct Standard<unit::NonPrefixable<UT, U>, ST>
00708     {
00709       static const ST ratio;
00710       static const bool exact;
00711     };
00712 
00714 
00718   template<class UT, class U, class ST>
00719     struct Standard<unit::Prefixable<UT, U>, ST>
00720     {
00721       static const ST ratio;
00722       static const bool exact;
00723     };
00724 
00726 
00730   template<class UT, class CUL, class ST>
00731     struct Standard<unit::ComposeBase<UT, CUL>, ST>
00732     {
00733       static const ST ratio;
00734       static const bool exact;
00735     };
00736 
00738 
00743   template<class UL, class PL, class ST = double> class CompStd;
00744 
00746 
00749   template<class UT, class U, class CULTail, long N, long D, 
00750                                                   class PTail, class ST>
00751     class CompStd<Loki::Typelist<unit::NonPrefixable<UT, U>, CULTail>,
00752                  Loki::Typelist<BSUtilities::Rational<N, D>, PTail>, ST>
00753   {
00754     public:
00755       static ST ratio (void)
00756         {return std::pow (Standard<unit::NonPrefixable<UT, U> >::ratio,
00757           static_cast<double>(N)/static_cast<double>(D)) 
00758                                * CompStd<CULTail, PTail, ST>::ratio ();}
00759 
00760       static bool exact (void)
00761         {return (Standard<unit::NonPrefixable<UT, U> >::exact
00762                              && CompStd<CULTail, PTail, ST>::exact ());}
00763   };
00764 
00766 
00769   template<class UT, class U, class P, class CULTail, long N, long D, 
00770                                                   class PTail, class ST>
00771     class CompStd<Loki::Typelist<unit::Prefixed<
00772       unit::Prefixable<UT, U>, P>, CULTail>, 
00773                  Loki::Typelist<BSUtilities::Rational<N, D>, PTail>, ST>
00774   {
00775     public:
00776       static ST ratio (void)
00777         {return std::pow ((Standard<unit::Prefixable<UT, U> >::ratio 
00778           * P::Factor), static_cast<double>(N)/static_cast<double>(D)) 
00779                                * CompStd<CULTail, PTail, ST>::ratio ();}
00780 
00781       static bool exact (void)
00782         {return (Standard<unit::Prefixable<UT, U> >::exact
00783                              && CompStd<CULTail, PTail, ST>::exact ());}
00784   };
00785 
00787 
00790   template<class UT, class CEL, class UL, class CULTail, long N, long D,
00791                                                   class PTail, class ST>
00792     class CompStd<Loki::Typelist<unit::Composed<
00793       unit::ComposeBase<UT, CEL>, UL>, CULTail>, 
00794                  Loki::Typelist<BSUtilities::Rational<N, D>, PTail>, ST>
00795   {
00796     public:
00797       static ST ratio (void)
00798         {return std::pow 
00799           (Standard<unit::ComposeBase<UT, CEL> >::ratio, 
00800             static_cast<double>(N)/static_cast<double>(D)) 
00801                                * CompStd<CULTail, PTail, ST>::ratio ();}
00802       static bool exact (void)
00803         {return (Standard<unit::ComposeBase<UT, CEL> >::exact 
00804                              && CompStd<CULTail, PTail, ST>::exact ());}
00805   };
00806 
00808 
00811   template<class UT, class U, long N, long D, class ST>
00812     class CompStd<Loki::Typelist<unit::NonPrefixable<UT, U>, 
00813       Loki::NullType>, Loki::Typelist<BSUtilities::Rational<N, D>, 
00814                                                     Loki::NullType>, ST>
00815   {
00816     public:
00817       static ST ratio (void) {return std::pow 
00818         (Standard<unit::NonPrefixable<UT, U> >::ratio, 
00819                         static_cast<double>(N)/static_cast<double>(D));}
00820 
00821       static bool exact (void)
00822                  {return Standard<unit::NonPrefixable<UT, U> >::exact;}
00823   };
00824 
00826 
00829   template<class UT, class U, class P, long N, long D, class ST>
00830     class CompStd<Loki::Typelist<unit::Prefixed<
00831       unit::Prefixable<UT, U>, P>, Loki::NullType>, 
00832         Loki::Typelist<BSUtilities::Rational<N, D>, Loki::NullType>, ST>
00833   {
00834     public:
00835       static ST ratio (void) {return std::pow 
00836         ((Standard<unit::Prefixable<UT, U> >::ratio * P::Factor), 
00837                         static_cast<double>(N)/static_cast<double>(D));}
00838 
00839       static bool exact (void)
00840                     {return Standard<unit::Prefixable<UT, U> >::exact;}
00841   };
00842 
00844 
00847   template<class UT, class CEL, class UL, long N, long D, class ST>
00848     class CompStd<Loki::Typelist<unit::Composed<
00849       unit::ComposeBase<UT, CEL>, UL>, Loki::NullType>, 
00850         Loki::Typelist<BSUtilities::Rational<N, D>, Loki::NullType>, ST>
00851   {
00852     public:
00853       static ST ratio (void) {return std::pow 
00854         (Standard<unit::ComposeBase<UT, CEL> >::ratio, 
00855                         static_cast<double>(N)/static_cast<double>(D));}
00856 
00857       static bool exact (void)
00858         {return Standard<unit::ComposeBase<UT, CEL> >::exact;}
00859   };
00860 
00862 
00864   template<class U, class ST = double> struct Standardize;
00865 
00867 
00872   template<class UT, class U, class ST>
00873     struct Standardize<unit::NonPrefixable<UT, U>, ST>
00874     {
00875       static ST VAL (const ST &value)
00876         {return value * 
00877                       Standard<unit::NonPrefixable<UT, U>, ST>::ratio;}
00878 
00879       static bool Exact (void)
00880               {return Standard<unit::NonPrefixable<UT, U>, ST>::exact;}
00881     };
00882 
00884 
00889   template<class UT, class U, class P, class ST>
00890     struct 
00891        Standardize<unit::Prefixed<unit::Prefixable<UT, U>, P>, ST>
00892     {
00893       static ST VAL (const ST &value)
00894         {return ST (value * P::Factor *
00895                         Standard<unit::Prefixable<UT, U>, ST>::ratio);}
00896 
00897       static bool Exact (void)
00898                  {return Standard<unit::Prefixable<UT, U>, ST>::exact;}
00899     };
00900 
00902 
00907   template<class UT, class CUL, class CEL, class ST>
00908     struct Standardize<unit::Composed<unit::ComposeBase<UT, CEL>, 
00909                                                                CUL>, ST>
00910     {
00911       static ST VAL (const ST &value)
00912         {return ST (value * CompStd<CUL, 
00913           typename unit::ComposeBase<UT, CEL>::Powers::Powers, ST>
00914             ::ratio () * 
00915                      Standard<unit::ComposeBase<UT, CEL>, ST>::ratio);}
00916 
00917       static bool Exact (void)
00918         {return CompStd<CUL, typename 
00919             unit::ComposeBase<UT, CEL>::Powers::Powers, ST>::exact ();}
00920     };
00921 
00923 
00925   template<class U, class ST = double> struct Reverse;
00926 
00928 
00933   template<class UT, class U, class ST>
00934     struct Reverse<unit::NonPrefixable<UT, U>, ST>
00935     {
00936       static ST VAL (const ST &value)
00937           {return value / 
00938                   Standard<unit::NonPrefixable<UT, U>, ST>::ratio;}
00939 
00940       static bool Exact (void)
00941               {return Standard<unit::NonPrefixable<UT, U>, ST>::exact;}
00942     };
00943 
00945 
00950   template<class UT, class U, class P, class ST>
00951     struct Reverse<unit::Prefixed<unit::Prefixable<UT, U>, P>, ST>
00952     {
00953       static ST VAL (const ST &value)
00954           {return ST (value / (P::Factor *
00955                        Standard<unit::Prefixable<UT, U>, ST>::ratio));}
00956 
00957       static bool Exact (void)
00958                  {return Standard<unit::Prefixable<UT, U>, ST>::exact;}
00959     };
00960 
00962 
00967   template<class UT, class CUL, class CEL, class ST>
00968     struct Reverse<unit::Composed<unit::ComposeBase<UT, CEL>, CUL>, 
00969                                                                      ST>
00970     {
00971       static ST VAL (const ST &value)
00972           {return 
00973             ST (value / (CompStd<CUL, 
00974             typename unit::ComposeBase<UT, CEL>::Powers::Powers, 
00975               ST>::ratio () * 
00976                    Standard<unit::ComposeBase<UT, CEL>, ST>::ratio));}
00977 
00978       static bool Exact (void)
00979         {return CompStd<CUL, typename 
00980             unit::ComposeBase<UT, CEL>::Powers::Powers, ST>::exact ();}
00981     };
00982 
00984 
00986   template<class UL> struct dynamic_standardize;
00987 
00989 
00996   template<class Head, class Tail>
00997     struct dynamic_standardize<Loki::Typelist<Head, Tail> >
00998     {
00999       template<class U, class ST>
01000         static ST VAL (const ST &value, const U &unit)
01001           {Head test = Head ();
01002            if (typeid(unit) == typeid(test))
01003              return Standardize<Head, ST>::VAL (value);
01004            else
01005              return dynamic_standardize<Tail>::VAL (value, unit);
01006           }
01007     };
01008          
01010 
01012   template<>
01013     struct dynamic_standardize<Loki::NullType>
01014     {
01015       template<class U, class ST>
01016         static ST VAL (const ST &, const U &)
01017                          {throw UnitMismatch (); return ST (0);}
01018     };
01019 
01021 
01023   template<class UL> struct dynamic_reverse;
01024  
01026 
01033   template<class Head, class Tail> 
01034     struct dynamic_reverse<Loki::Typelist<Head, Tail> >
01035     {
01036       template<class U, class ST>
01037         static ST VAL (const ST &value, const U &unit)
01038           {Head test = Head ();
01039            if (typeid(unit) == typeid (test))
01040              return Reverse<Head, ST>::VAL (value);
01041            else
01042              return dynamic_reverse<Tail>::VAL (value, unit);
01043           }
01044     };
01045          
01047 
01049   template<>
01050     struct dynamic_reverse<Loki::NullType>
01051     {
01052       template<class U, class ST>
01053       static ST VAL (const ST &, const U &)
01054                           {throw UnitMismatch (); return ST (0);}
01055     };
01056 
01058 
01066 template<long RL_N, long RL_D, long RM_N, long RM_D,
01067   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D,
01068     long RA_N, long RA_D, long RLU_N, long RLU_D, class UT, 
01069                              class Head, class Tail, class DU, class ST>
01070   class Quantity<
01071     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01072       BSUtilities::Rational<RM_N, RM_D>,
01073         BSUtilities::Rational<RT_N, RT_D>,
01074           BSUtilities::Rational<RE_N, RE_D>,
01075             BSUtilities::Rational<RTE_N, RTE_D>,
01076               BSUtilities::Rational<RA_N, RA_D>,
01077                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01078                   UT, Loki::Typelist<Head, Tail>, DU, ST> 
01079                                                      : public Quantities
01080   {
01081     public:
01083 
01085       typedef dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01086         BSUtilities::Rational<RM_N, RM_D>,
01087           BSUtilities::Rational<RT_N, RT_D>,
01088             BSUtilities::Rational<RE_N, RE_D>,
01089               BSUtilities::Rational<RTE_N, RTE_D>,
01090                 BSUtilities::Rational<RA_N, RA_D>,
01091                               BSUtilities::Rational<RLU_N, RLU_D> > Dim;
01092 
01093     private:
01095       static const bool Dimensionless = Dim::IsDimensionless;
01096 
01097     protected:
01099 
01101       std::string namestring;
01103 
01105       std::string symbolstring;
01106 
01108 
01110       unit::Unit<UT> * findBySymbol (const std::string &unitsymbol)
01111          {return UnitPointerBySymbol<UT, Loki::Typelist<Head, Tail> >
01112                                                  ::result (unitsymbol);}
01113 
01115 
01120    template<class U>
01121      static ST standard (const ST value, const U&)
01122        {return Standardize<typename CheckAgainstAllUnits<U, 
01123                         Loki::Typelist<Head, Tail> >::RET, ST> (value);}
01124 
01126 
01131    template<class U>
01132      static ST reverse (const ST value, const U& unit)
01133        {return Reverse<typename CheckAgainstAllUnits<U, 
01134                         Loki::Typelist<Head, Tail> >::RET, ST> (value);}
01135 
01136     public:
01138 
01141       Quantity (void) 
01142         : namestring (quantity::Name<Quantity<Dim, UT, 
01143           Loki::Typelist<Head, Tail>, DU, ST> >::String), 
01144           symbolstring (quantity::Symbol<Quantity<Dim, UT, 
01145                        Loki::Typelist<Head, Tail>, DU, ST> >::String) {}
01146 
01148 
01151       virtual ~Quantity (void) {}
01152 
01154 
01157       typedef AllUnits<UT, Loki::Typelist<Head, Tail> > AllUnits;
01158 
01160 
01163       typedef DefaultUnit<UT, DU> DefaultUnit;
01164 
01166       std::string name (void) const {return namestring;}
01168       std::string symbol (void) const {return symbolstring;}
01169 
01171 /*  direct static access
01172 */
01173       static const std::string Name (void) 
01174         {return quantity::Name<Quantity<Dim, UT, 
01175                          Loki::Typelist<Head, Tail>, DU, ST> >::String;}
01176 
01178 /*  direct static access
01179 */
01180       static const std::string Symbol (void) 
01181         {return quantity::Symbol<Quantity<Dim, UT, 
01182                          Loki::Typelist<Head, Tail>, DU, ST> >::String;}
01183 
01185       void name (const std::string &name) {namestring = name;}
01187       void symbol (const std::string &symbol) {symbolstring = symbol;}
01188 
01190 
01192       virtual ST standard_value (void) const = 0;
01193 
01195 
01197       virtual ST value (void) const = 0;
01198 
01200 
01202 //      static const bool _IsDimensionless = Dim::IsDimensionless;
01203       static const bool IsDimensionless (void) {return Dimensionless;}
01204 
01206 
01208       const bool isDimensionless (void) const 
01209                                             {return IsDimensionless ();}
01210 
01212 
01217       friend std::ostream & operator<< 
01218                             (std::ostream &os, const Quantity &quantity)
01219              {return quantity.print (os);}
01220 
01222 
01236       std::ostream & print (std::ostream &os) const
01237         {
01238           std::string name (""); 
01239           std::string symbol ("");
01240           std::string equal ("");
01241 
01242           if (PS.name ())
01243             name = namestring + " ";
01244 
01245           if (PS.symbol ())
01246             symbol = symbolstring + " ";
01247 
01248           if (PS.name () || PS.symbol ())
01249             equal = "= ";
01250 
01251           os << name << symbol << equal;
01252 
01253           return print_value (os);
01254         }
01255 
01257 
01260       virtual std::ostream & print_value (std::ostream &os) const = 0;
01261 
01263       friend void operator<< 
01264         (std::string &str, const Quantity &quantity) {quantity >> str;}
01265 
01267       virtual void operator>> (std::string &str) const = 0;
01268 
01270 
01273       operator std::string () const 
01274         {std::string string; *this >> string; return string;}
01275 
01277 
01280       virtual std::ostream & operator>> (std::ostream &os) const = 0;
01281 
01282   };
01283 
01285 //
01286 //  helper structures, classes, and functions which use the 
01287 //  Quantity template
01288 //
01290 
01292 
01294       struct Dummy;
01295 
01297 
01302 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01303   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01304     long RA_N, long RA_D, long RLU_N, long RLU_D, 
01305                                            class UL, class DU, class ST>
01306   struct Exp {static ST exec (const Quantity<
01307     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01308       BSUtilities::Rational<RM_N, RM_D>,
01309         BSUtilities::Rational<RT_N, RT_D>,
01310           BSUtilities::Rational<RE_N, RE_D>,
01311             BSUtilities::Rational<RTE_N, RTE_D>,
01312               BSUtilities::Rational<RA_N, RA_D>,
01313                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01314                                               UT, UL, DU, ST> &quantity)
01315                               {return ST(std::exp (quantity.value ()));}
01316              };
01317 
01319 
01324 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01325   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01326     long RA_N, long RA_D, long RLU_N, long RLU_D,
01327                                            class UL, class DU, class ST>
01328   inline ST exp (const Quantity<
01329     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01330       BSUtilities::Rational<RM_N, RM_D>,
01331         BSUtilities::Rational<RT_N, RT_D>,
01332           BSUtilities::Rational<RE_N, RE_D>,
01333             BSUtilities::Rational<RTE_N, RTE_D>,
01334               BSUtilities::Rational<RA_N, RA_D>,
01335                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01336                                               UT, UL, DU, ST> &quantity)
01337     {return ST(BSUtilities::IF<CheckDimensionality<Quantity<
01338       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01339         BSUtilities::Rational<RM_N, RM_D>,
01340           BSUtilities::Rational<RT_N, RT_D>,
01341             BSUtilities::Rational<RE_N, RE_D>,
01342               BSUtilities::Rational<RTE_N, RTE_D>,
01343                 BSUtilities::Rational<RA_N, RA_D>,
01344                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01345                                                  UT, UL, DU, ST> >::RET,
01346      typename 
01347        Exp<UT, RL_N, RL_D, RM_N, RM_D, RT_N, RT_D, RE_N, RE_D, 
01348          RTE_N, RTE_D, RA_N, RA_D, RLU_N, RLU_D, UL, DU, ST>::Exp, 
01349                                           Dummy>::RET::exec (quantity));
01350         }
01351 
01353 
01358 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01359   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01360     long RA_N, long RA_D, long RLU_N, long RLU_D,
01361                                            class UL, class DU, class ST>
01362   struct Log {static ST exec (const Quantity<
01363     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01364       BSUtilities::Rational<RM_N, RM_D>,
01365         BSUtilities::Rational<RT_N, RT_D>,
01366           BSUtilities::Rational<RE_N, RE_D>,
01367             BSUtilities::Rational<RTE_N, RTE_D>,
01368               BSUtilities::Rational<RA_N, RA_D>,
01369                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01370                                               UT, UL, DU, ST> &quantity)
01371                               {return ST(std::log (quantity.value ()));}
01372              };
01373 
01375 
01380 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01381   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01382     long RA_N, long RA_D, long RLU_N, long RLU_D,
01383                                            class UL, class DU, class ST>
01384   inline ST log (const Quantity<
01385     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01386       BSUtilities::Rational<RM_N, RM_D>,
01387         BSUtilities::Rational<RT_N, RT_D>,
01388           BSUtilities::Rational<RE_N, RE_D>,
01389             BSUtilities::Rational<RTE_N, RTE_D>,
01390               BSUtilities::Rational<RA_N, RA_D>,
01391                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01392                                               UT, UL, DU, ST> &quantity)
01393     {return ST(BSUtilities::IF<CheckDimensionality<Quantity<
01394       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01395         BSUtilities::Rational<RM_N, RM_D>,
01396           BSUtilities::Rational<RT_N, RT_D>,
01397             BSUtilities::Rational<RE_N, RE_D>,
01398               BSUtilities::Rational<RTE_N, RTE_D>,
01399                 BSUtilities::Rational<RA_N, RA_D>,
01400                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01401                                                  UT, UL, DU, ST> >::RET,
01402      typename 
01403        Log<UT, RL_N, RL_D, RM_N, RM_D, RT_N, RT_D, RE_N, RE_D, RTE_N, 
01404          RTE_D, RA_N, RA_D, RLU_N, RLU_D, UL, DU, ST>::Log, 
01405                                           Dummy>::RET::exec (quantity));
01406         }
01407 
01409 
01414 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01415   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01416     long RA_N, long RA_D, long RLU_N, long RLU_D,
01417                                            class UL, class DU, class ST>
01418   struct Log10 {static ST exec (const Quantity<
01419     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01420       BSUtilities::Rational<RM_N, RM_D>,
01421         BSUtilities::Rational<RT_N, RT_D>,
01422           BSUtilities::Rational<RE_N, RE_D>,
01423             BSUtilities::Rational<RTE_N, RTE_D>,
01424               BSUtilities::Rational<RA_N, RA_D>,
01425                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01426                                               UT, UL, DU, ST> &quantity)
01427                             {return ST(std::log10 (quantity.value ()));}
01428              };
01429 
01431 
01436 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01437   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01438     long RA_N, long RA_D, long RLU_N, long RLU_D,
01439                                            class UL, class DU, class ST>
01440   inline ST log10 (const Quantity<
01441     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01442       BSUtilities::Rational<RM_N, RM_D>,
01443         BSUtilities::Rational<RT_N, RT_D>,
01444           BSUtilities::Rational<RE_N, RE_D>,
01445             BSUtilities::Rational<RTE_N, RTE_D>,
01446               BSUtilities::Rational<RA_N, RA_D>,
01447                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01448                                               UT, UL, DU, ST> &quantity)
01449     {return ST(BSUtilities::IF<CheckDimensionality<Quantity<
01450       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01451         BSUtilities::Rational<RM_N, RM_D>,
01452           BSUtilities::Rational<RT_N, RT_D>,
01453             BSUtilities::Rational<RE_N, RE_D>,
01454               BSUtilities::Rational<RTE_N, RTE_D>,
01455                 BSUtilities::Rational<RA_N, RA_D>,
01456                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01457                                                  UT, UL, DU, ST> >::RET,
01458      typename 
01459        Log10<UT, RL_N, RL_D, RM_N, RM_D, RT_N, RT_D, RE_N, RE_D, RTE_N, 
01460          RTE_D, RA_N, RA_D, RLU_N, RLU_D, UL, DU, ST>::Log10, 
01461                                           Dummy>::RET::exec (quantity));
01462         }
01463 
01465 
01470 template<class D, class UT, class UL, class DU, class ST>
01471   struct Sin 
01472     {static ST exec (const Quantity<D, UT, UL, DU, ST> &quantity)
01473                             {return ST(std::sin (quantity.value ()));}
01474     };
01475 
01477 
01482 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01483   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01484     long RA_N, long RA_D, long RLU_N, long RLU_D,
01485                                            class UL, class DU, class ST>
01486   inline ST sin (const Quantity<
01487     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01488       BSUtilities::Rational<RM_N, RM_D>,
01489         BSUtilities::Rational<RT_N, RT_D>,
01490           BSUtilities::Rational<RE_N, RE_D>,
01491             BSUtilities::Rational<RTE_N, RTE_D>,
01492               BSUtilities::Rational<RA_N, RA_D>,
01493                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01494                                               UT, UL, DU, ST> &quantity)
01495     {return ST(BSUtilities::IF<CheckDimensionality<Quantity<
01496       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01497         BSUtilities::Rational<RM_N, RM_D>,
01498           BSUtilities::Rational<RT_N, RT_D>,
01499             BSUtilities::Rational<RE_N, RE_D>,
01500               BSUtilities::Rational<RTE_N, RTE_D>,
01501                 BSUtilities::Rational<RA_N, RA_D>,
01502                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01503                                                  UT, UL, DU, ST> >::RET,
01504      typename 
01505        Sin<dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01506         BSUtilities::Rational<RM_N, RM_D>,
01507           BSUtilities::Rational<RT_N, RT_D>,
01508             BSUtilities::Rational<RE_N, RE_D>,
01509               BSUtilities::Rational<RTE_N, RTE_D>,
01510                 BSUtilities::Rational<RA_N, RA_D>,
01511                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01512                     UT, UL, DU, ST>::Sin, Dummy>::RET::exec (quantity));
01513         }
01514 
01516 
01521 template<class D, class UT, class UL, class DU, class ST>
01522   struct Cos 
01523     {static ST exec (const Quantity<D, UT, UL, DU, ST> &quantity)
01524                             {return ST(std::cos (quantity.value ()));}
01525     };
01526 
01528 
01533 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01534   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01535     long RA_N, long RA_D, long RLU_N, long RLU_D,
01536                                            class UL, class DU, class ST>
01537   inline ST cos (const Quantity<
01538     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01539       BSUtilities::Rational<RM_N, RM_D>,
01540         BSUtilities::Rational<RT_N, RT_D>,
01541           BSUtilities::Rational<RE_N, RE_D>,
01542             BSUtilities::Rational<RTE_N, RTE_D>,
01543               BSUtilities::Rational<RA_N, RA_D>,
01544                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01545                                               UT, UL, DU, ST> &quantity)
01546     {return ST(BSUtilities::IF<CheckDimensionality<Quantity<
01547       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01548         BSUtilities::Rational<RM_N, RM_D>,
01549           BSUtilities::Rational<RT_N, RT_D>,
01550             BSUtilities::Rational<RE_N, RE_D>,
01551               BSUtilities::Rational<RTE_N, RTE_D>,
01552                 BSUtilities::Rational<RA_N, RA_D>,
01553                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01554                                                  UT, UL, DU, ST> >::RET,
01555      typename 
01556        Cos<dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01557         BSUtilities::Rational<RM_N, RM_D>,
01558           BSUtilities::Rational<RT_N, RT_D>,
01559             BSUtilities::Rational<RE_N, RE_D>,
01560               BSUtilities::Rational<RTE_N, RTE_D>,
01561                 BSUtilities::Rational<RA_N, RA_D>,
01562                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01563                     UT, UL, DU, ST>::Cos, Dummy>::RET::exec (quantity));
01564         }
01565 
01567 
01572 template<class D, class UT, class UL, class DU, class ST>
01573   struct Tan 
01574     {static ST exec (const Quantity<D, UT, UL, DU, ST> &quantity)
01575                             {return ST(std::tan (quantity.value ()));}
01576     };
01577 
01579 
01584 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01585   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01586     long RA_N, long RA_D, long RLU_N, long RLU_D,
01587                                            class UL, class DU, class ST>
01588   inline ST tan (const Quantity<
01589     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01590       BSUtilities::Rational<RM_N, RM_D>,
01591         BSUtilities::Rational<RT_N, RT_D>,
01592           BSUtilities::Rational<RE_N, RE_D>,
01593             BSUtilities::Rational<RTE_N, RTE_D>,
01594               BSUtilities::Rational<RA_N, RA_D>,
01595                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01596                                               UT, UL, DU, ST> &quantity)
01597     {return ST(BSUtilities::IF<CheckDimensionality<Quantity<
01598       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01599         BSUtilities::Rational<RM_N, RM_D>,
01600           BSUtilities::Rational<RT_N, RT_D>,
01601             BSUtilities::Rational<RE_N, RE_D>,
01602               BSUtilities::Rational<RTE_N, RTE_D>,
01603                 BSUtilities::Rational<RA_N, RA_D>,
01604                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01605                                                  UT, UL, DU, ST> >::RET,
01606      typename 
01607        Tan<dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01608         BSUtilities::Rational<RM_N, RM_D>,
01609           BSUtilities::Rational<RT_N, RT_D>,
01610             BSUtilities::Rational<RE_N, RE_D>,
01611               BSUtilities::Rational<RTE_N, RTE_D>,
01612                 BSUtilities::Rational<RA_N, RA_D>,
01613                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01614                     UT, UL, DU, ST>::Tan, Dummy>::RET::exec (quantity));
01615         }
01616 
01618 
01623 template<class D, class UT, class UL, class DU, class ST>
01624   struct Sinh 
01625     {static ST exec (const Quantity<D, UT, UL, DU, ST> &quantity)
01626                             {return ST(std::sinh (quantity.value ()));}
01627     };
01628 
01630 
01635 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01636   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01637     long RA_N, long RA_D, long RLU_N, long RLU_D,
01638                                            class UL, class DU, class ST>
01639   inline ST sinh (const Quantity<
01640     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01641       BSUtilities::Rational<RM_N, RM_D>,
01642         BSUtilities::Rational<RT_N, RT_D>,
01643           BSUtilities::Rational<RE_N, RE_D>,
01644             BSUtilities::Rational<RTE_N, RTE_D>,
01645               BSUtilities::Rational<RA_N, RA_D>,
01646                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01647                                               UT, UL, DU, ST> &quantity)
01648     {return ST(BSUtilities::IF<CheckDimensionality<Quantity<
01649       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01650         BSUtilities::Rational<RM_N, RM_D>,
01651           BSUtilities::Rational<RT_N, RT_D>,
01652             BSUtilities::Rational<RE_N, RE_D>,
01653               BSUtilities::Rational<RTE_N, RTE_D>,
01654                 BSUtilities::Rational<RA_N, RA_D>,
01655                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01656                                                  UT, UL, DU, ST> >::RET,
01657      typename 
01658        Sinh<dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01659         BSUtilities::Rational<RM_N, RM_D>,
01660           BSUtilities::Rational<RT_N, RT_D>,
01661             BSUtilities::Rational<RE_N, RE_D>,
01662               BSUtilities::Rational<RTE_N, RTE_D>,
01663                 BSUtilities::Rational<RA_N, RA_D>,
01664                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01665                    UT, UL, DU, ST>::Sinh, Dummy>::RET::exec (quantity));
01666         }
01667 
01669 
01674 template<class D, class UT, class UL, class DU, class ST>
01675   struct Cosh 
01676     {static ST exec (const Quantity<D, UT, UL, DU, ST> &quantity)
01677                             {return ST(std::cosh (quantity.value ()));}
01678     };
01679 
01681 
01686 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01687   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01688     long RA_N, long RA_D, long RLU_N, long RLU_D,
01689                                            class UL, class DU, class ST>
01690   inline ST cosh (const Quantity<
01691     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01692       BSUtilities::Rational<RM_N, RM_D>,
01693         BSUtilities::Rational<RT_N, RT_D>,
01694           BSUtilities::Rational<RE_N, RE_D>,
01695             BSUtilities::Rational<RTE_N, RTE_D>,
01696               BSUtilities::Rational<RA_N, RA_D>,
01697                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01698                                               UT, UL, DU, ST> &quantity)
01699     {return ST(BSUtilities::IF<CheckDimensionality<Quantity<
01700       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01701         BSUtilities::Rational<RM_N, RM_D>,
01702           BSUtilities::Rational<RT_N, RT_D>,
01703             BSUtilities::Rational<RE_N, RE_D>,
01704               BSUtilities::Rational<RTE_N, RTE_D>,
01705                 BSUtilities::Rational<RA_N, RA_D>,
01706                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01707                                                  UT, UL, DU, ST> >::RET,
01708      typename 
01709        Cosh<dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01710         BSUtilities::Rational<RM_N, RM_D>,
01711           BSUtilities::Rational<RT_N, RT_D>,
01712             BSUtilities::Rational<RE_N, RE_D>,
01713               BSUtilities::Rational<RTE_N, RTE_D>,
01714                 BSUtilities::Rational<RA_N, RA_D>,
01715                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01716                    UT, UL, DU, ST>::Cosh, Dummy>::RET::exec (quantity));
01717         }
01718 
01720 
01725 template<class D, class UT, class UL, class DU, class ST>
01726   struct Tanh 
01727     {static ST exec (const Quantity<D, UT, UL, DU, ST> &quantity)
01728                             {return ST(std::tanh (quantity.value ()));}
01729     };
01730 
01732 
01737 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01738   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01739     long RA_N, long RA_D, long RLU_N, long RLU_D,
01740                                            class UL, class DU, class ST>
01741   inline ST tanh (const Quantity<
01742     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01743       BSUtilities::Rational<RM_N, RM_D>,
01744         BSUtilities::Rational<RT_N, RT_D>,
01745           BSUtilities::Rational<RE_N, RE_D>,
01746             BSUtilities::Rational<RTE_N, RTE_D>,
01747               BSUtilities::Rational<RA_N, RA_D>,
01748                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01749                                               UT, UL, DU, ST> &quantity)
01750     {return ST(BSUtilities::IF<CheckDimensionality<Quantity<
01751       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01752         BSUtilities::Rational<RM_N, RM_D>,
01753           BSUtilities::Rational<RT_N, RT_D>,
01754             BSUtilities::Rational<RE_N, RE_D>,
01755               BSUtilities::Rational<RTE_N, RTE_D>,
01756                 BSUtilities::Rational<RA_N, RA_D>,
01757                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01758                                                  UT, UL, DU, ST> >::RET,
01759      typename 
01760        Tanh<dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01761         BSUtilities::Rational<RM_N, RM_D>,
01762           BSUtilities::Rational<RT_N, RT_D>,
01763             BSUtilities::Rational<RE_N, RE_D>,
01764               BSUtilities::Rational<RTE_N, RTE_D>,
01765                 BSUtilities::Rational<RA_N, RA_D>,
01766                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01767                    UT, UL, DU, ST>::Tanh, Dummy>::RET::exec (quantity));
01768         }
01769 
01771 
01776 template<class D, class UT, class UL, class DU, class ST>
01777   struct Asin 
01778     {static ST exec (const Quantity<D, UT, UL, DU, ST> &quantity)
01779                             {return ST(std::asin (quantity.value ()));}
01780     };
01781 
01783 
01788 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01789   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01790     long RA_N, long RA_D, long RLU_N, long RLU_D,
01791                                            class UL, class DU, class ST>
01792   inline ST asin (const Quantity<
01793     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01794       BSUtilities::Rational<RM_N, RM_D>,
01795         BSUtilities::Rational<RT_N, RT_D>,
01796           BSUtilities::Rational<RE_N, RE_D>,
01797             BSUtilities::Rational<RTE_N, RTE_D>,
01798               BSUtilities::Rational<RA_N, RA_D>,
01799                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01800                                               UT, UL, DU, ST> &quantity)
01801     {return ST(BSUtilities::IF<CheckDimensionality<Quantity<
01802       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01803         BSUtilities::Rational<RM_N, RM_D>,
01804           BSUtilities::Rational<RT_N, RT_D>,
01805             BSUtilities::Rational<RE_N, RE_D>,
01806               BSUtilities::Rational<RTE_N, RTE_D>,
01807                 BSUtilities::Rational<RA_N, RA_D>,
01808                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01809                                                  UT, UL, DU, ST> >::RET,
01810      typename 
01811        Asin<dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01812         BSUtilities::Rational<RM_N, RM_D>,
01813           BSUtilities::Rational<RT_N, RT_D>,
01814             BSUtilities::Rational<RE_N, RE_D>,
01815               BSUtilities::Rational<RTE_N, RTE_D>,
01816                 BSUtilities::Rational<RA_N, RA_D>,
01817                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01818                    UT, UL, DU, ST>::Asin, Dummy>::RET::exec (quantity));
01819         }
01820 
01822 
01827 template<class D, class UT, class UL, class DU, class ST>
01828   struct Acos 
01829     {static ST exec (const Quantity<D, UT, UL, DU, ST> &quantity)
01830                             {return ST(std::acos (quantity.value ()));}
01831     };
01832 
01834 
01839 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01840   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01841     long RA_N, long RA_D, long RLU_N, long RLU_D,
01842                                            class UL, class DU, class ST>
01843   inline ST acos (const Quantity<
01844     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01845       BSUtilities::Rational<RM_N, RM_D>,
01846         BSUtilities::Rational<RT_N, RT_D>,
01847           BSUtilities::Rational<RE_N, RE_D>,
01848             BSUtilities::Rational<RTE_N, RTE_D>,
01849               BSUtilities::Rational<RA_N, RA_D>,
01850                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01851                                               UT, UL, DU, ST> &quantity)
01852     {return ST(BSUtilities::IF<CheckDimensionality<Quantity<
01853       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01854         BSUtilities::Rational<RM_N, RM_D>,
01855           BSUtilities::Rational<RT_N, RT_D>,
01856             BSUtilities::Rational<RE_N, RE_D>,
01857               BSUtilities::Rational<RTE_N, RTE_D>,
01858                 BSUtilities::Rational<RA_N, RA_D>,
01859                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01860                                                  UT, UL, DU, ST> >::RET,
01861      typename 
01862        Acos<dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01863         BSUtilities::Rational<RM_N, RM_D>,
01864           BSUtilities::Rational<RT_N, RT_D>,
01865             BSUtilities::Rational<RE_N, RE_D>,
01866               BSUtilities::Rational<RTE_N, RTE_D>,
01867                 BSUtilities::Rational<RA_N, RA_D>,
01868                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01869                    UT, UL, DU, ST>::Acos, Dummy>::RET::exec (quantity));
01870         }
01871 
01873 
01878 template<class D, class UT, class UL, class DU, class ST>
01879   struct Atan 
01880     {static ST exec (const Quantity<D, UT, UL, DU, ST> &quantity)
01881                             {return ST(std::atan (quantity.value ()));}
01882     };
01883 
01885 
01890 template<class UT, long RL_N, long RL_D, long RM_N, long RM_D, 
01891   long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, 
01892     long RA_N, long RA_D, long RLU_N, long RLU_D,
01893                                            class UL, class DU, class ST>
01894   inline ST atan (const Quantity<
01895     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01896       BSUtilities::Rational<RM_N, RM_D>,
01897         BSUtilities::Rational<RT_N, RT_D>,
01898           BSUtilities::Rational<RE_N, RE_D>,
01899             BSUtilities::Rational<RTE_N, RTE_D>,
01900               BSUtilities::Rational<RA_N, RA_D>,
01901                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01902                                               UT, UL, DU, ST> &quantity)
01903     {return ST(BSUtilities::IF<CheckDimensionality<Quantity<
01904       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01905         BSUtilities::Rational<RM_N, RM_D>,
01906           BSUtilities::Rational<RT_N, RT_D>,
01907             BSUtilities::Rational<RE_N, RE_D>,
01908               BSUtilities::Rational<RTE_N, RTE_D>,
01909                 BSUtilities::Rational<RA_N, RA_D>,
01910                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01911                                                  UT, UL, DU, ST> >::RET,
01912      typename 
01913        Atan<dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01914         BSUtilities::Rational<RM_N, RM_D>,
01915           BSUtilities::Rational<RT_N, RT_D>,
01916             BSUtilities::Rational<RE_N, RE_D>,
01917               BSUtilities::Rational<RTE_N, RTE_D>,
01918                 BSUtilities::Rational<RA_N, RA_D>,
01919                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01920                    UT, UL, DU, ST>::Atan, Dummy>::RET::exec (quantity));
01921         }
01922 
01924 
01927 template<class UT, 
01928   long RL_N, long RL_D, long RM_N, long RM_D, 
01929     long RT_N, long RT_D, long RE_N, long RE_D, 
01930       long RTE_N, long RTE_D, long RA_N, long RA_D, 
01931         long RLU_N, long RLU_D,
01932                               class UL1, class DU1, class ST1,
01933                               class UL2, class DU2, class ST2>
01934   inline ST1 atan2 (const Quantity<
01935     dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01936       BSUtilities::Rational<RM_N, RM_D>,
01937         BSUtilities::Rational<RT_N, RT_D>,
01938           BSUtilities::Rational<RE_N, RE_D>,
01939             BSUtilities::Rational<RTE_N, RTE_D>,
01940               BSUtilities::Rational<RA_N, RA_D>,
01941                 BSUtilities::Rational<RLU_N, RLU_D> >, 
01942                                       UT, UL1, DU1, ST1> &quantity,
01943     const Quantity<
01944       dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>,
01945         BSUtilities::Rational<RM_N, RM_D>,
01946           BSUtilities::Rational<RT_N, RT_D>,
01947             BSUtilities::Rational<RE_N, RE_D>,
01948               BSUtilities::Rational<RTE_N, RTE_D>,
01949                 BSUtilities::Rational<RA_N, RA_D>,
01950                   BSUtilities::Rational<RLU_N, RLU_D> >, 
01951                                      UT, UL2, DU2, ST2> &quantity2)
01952     {return ST1(std::atan2 (quantity.standard_value (), 
01953                                          quantity2.standard_value ()));}
01954 
01955 }
01956 
01957 #endif /* _Quantity_h */