physical Namespace Reference


Classes

struct  FixedPhysical
 physical quantity with compile-time fixed physical dimension. More...
struct  FixedPhysicalSum
 resulting type of the sum of two other quantities. More...
struct  FixedPhysicalRatio
 resulting type of the ratio of two other quantities. More...
struct  FixedPhysicalProduct
 resulting type of the product of two other quantities. More...
struct  FixedPhysicalBase
struct  FixedPhysicalBase< T,-1 >
struct  DynamicPhysical
struct  DynamicUnit
struct  IncompatibleUnitException
struct  FixedPhysicalSum< FixedPhysical< UnitSystem, T1, Exponents1 >, FixedPhysical< UnitSystem, T2, Exponents2 > >
 resulting type of the sum of two other quantities. More...
struct  FixedPhysicalRatio< FixedPhysical< UnitSystem, T1, Exponents1 >, FixedPhysical< UnitSystem, T2, Exponents2 > >
 resulting type of the ratio of two other quantities. More...
struct  FixedPhysicalProduct< FixedPhysical< UnitSystem, T1, Exponents1 >, FixedPhysical< UnitSystem, T2, Exponents2 > >
 resulting type of the product of two other quantities. More...
struct  FixedPhysicalBase< UnitSystem, T,-1 >

Namespaces

namespace  detail
namespace  format
namespace  parser
 parsing of physical quantities, i.e. conversion of a properly formatted string into a DynamicPhysical.
namespace  quantity_si_double
namespace  quantity_si_float
namespace  unit_si_double
namespace  unit_si_float
namespace  unitsymbol_si_double
namespace  unitsymbol_si_float

Functions

template<class UnitSystem>
std::ostream & operator<< (std::ostream &os, DynamicPhysical< UnitSystem > q)
template<typename T1, typename T2, class exponents>
FixedPhysicalSum< FixedPhysical<
T1, exponents >, FixedPhysical<
T2, exponents > >::type 		operator+ (const FixedPhysical< T1, exponents > a, FixedPhysical< T2, exponents > b)
template<typename T1, typename T2, class exponents>
FixedPhysicalSum< FixedPhysical<
T1, exponents >, FixedPhysical<
T2, exponents > >::type 		operator- (const FixedPhysical< T1, exponents > a, FixedPhysical< T2, exponents > b)
template<typename T1, typename T2, class exponents1, class exponents2>
FixedPhysicalProduct< FixedPhysical<
T1, exponents1 >, FixedPhysical<
T2, exponents2 > >::type 		operator * (const FixedPhysical< T1, exponents1 > a, FixedPhysical< T2, exponents2 > b)
template<typename T1, typename T2, class exponents1, class exponents2>
FixedPhysicalRatio< FixedPhysical<
T1, exponents1 >, FixedPhysical<
T2, exponents2 > >::type 		operator/ (const FixedPhysical< T1, exponents1 > a, FixedPhysical< T2, exponents2 > b)
template<typename T1, typename T2, class exponents>
bool operator== (const FixedPhysical< T1, exponents > a, FixedPhysical< T2, exponents > b)
template<typename T1, typename T2, class exponents>
bool operator!= (const FixedPhysical< T1, exponents > a, FixedPhysical< T2, exponents > b)
template<typename T1, typename T2, class exponents>
bool operator>= (const FixedPhysical< T1, exponents > a, FixedPhysical< T2, exponents > b)
template<typename T1, typename T2, class exponents>
bool operator<= (const FixedPhysical< T1, exponents > a, FixedPhysical< T2, exponents > b)
template<typename T1, typename T2, class exponents>
bool operator> (const FixedPhysical< T1, exponents > a, FixedPhysical< T2, exponents > b)
template<typename T1, typename T2, class exponents>
bool operator< (const FixedPhysical< T1, exponents > a, FixedPhysical< T2, exponents > b)
template<typename T1, typename T2, class exponents1>
FixedPhysical< typename detail::larger_type<
T1, T2 >::type, exponents1 > 		operator * (const T1 a, const FixedPhysical< T2, exponents1 > b)
template<class UnitSystem>
DynamicPhysical< UnitSystem > operator+ (DynamicPhysical< UnitSystem > a, DynamicPhysical< UnitSystem > b)
template<class UnitSystem>
DynamicPhysical< UnitSystem > operator- (DynamicPhysical< UnitSystem > a, DynamicPhysical< UnitSystem > b)
template<class UnitSystem>
DynamicPhysical< UnitSystem > operator * (DynamicPhysical< UnitSystem > a, DynamicPhysical< UnitSystem > b)
template<class UnitSystem>
DynamicPhysical< UnitSystem > operator * (double a, DynamicPhysical< UnitSystem > b)
template<class UnitSystem>
DynamicPhysical< UnitSystem > operator/ (DynamicPhysical< UnitSystem > a, DynamicPhysical< UnitSystem > b)
template<class UnitSystem>
bool operator== (DynamicPhysical< UnitSystem > a, DynamicPhysical< UnitSystem > b)
template<class UnitSystem>
bool operator!= (DynamicPhysical< UnitSystem > a, DynamicPhysical< UnitSystem > b)
template<class UnitSystem>
bool operator>= (DynamicPhysical< UnitSystem > a, DynamicPhysical< UnitSystem > b)
template<class UnitSystem>
bool operator<= (DynamicPhysical< UnitSystem > a, DynamicPhysical< UnitSystem > b)
template<class UnitSystem>
bool operator> (DynamicPhysical< UnitSystem > a, DynamicPhysical< UnitSystem > b)
template<class UnitSystem>
bool operator< (DynamicPhysical< UnitSystem > a, DynamicPhysical< UnitSystem > b)
template<class UnitSystem>
DynamicPhysical< UnitSystem > power (DynamicPhysical< UnitSystem > a, int n)
template<class UnitSystem>
DynamicPhysical< UnitSystem > operator * (double real, const DynamicUnit< UnitSystem > &unit)
template<class UnitSystem>
DynamicPhysical< UnitSystem > operator/ (DynamicPhysical< UnitSystem > quantity, const DynamicUnit< UnitSystem > unit)
template<class UnitSystem, typename T1, typename T2, class exponents>
FixedPhysicalSum< FixedPhysical<
UnitSystem, T1, exponents >,
FixedPhysical< UnitSystem,
T2, exponents > >::type 		operator+ (const FixedPhysical< UnitSystem, T1, exponents > a, FixedPhysical< UnitSystem, T2, exponents > b)
template<class UnitSystem, typename T1, typename T2, class exponents>
FixedPhysicalSum< FixedPhysical<
UnitSystem, T1, exponents >,
FixedPhysical< UnitSystem,
T2, exponents > >::type 		operator- (const FixedPhysical< UnitSystem, T1, exponents > a, FixedPhysical< UnitSystem, T2, exponents > b)
template<class UnitSystem, typename T1, typename T2, class exponents1, class exponents2>
FixedPhysicalProduct< FixedPhysical<
UnitSystem, T1, exponents1 >,
FixedPhysical< UnitSystem,
T2, exponents2 > >::type 		operator * (const FixedPhysical< UnitSystem, T1, exponents1 > a, FixedPhysical< UnitSystem, T2, exponents2 > b)
template<class UnitSystem, typename T1, typename T2, class exponents1, class exponents2>
FixedPhysicalRatio< FixedPhysical<
UnitSystem, T1, exponents1 >,
FixedPhysical< UnitSystem,
T2, exponents2 > >::type 		operator/ (const FixedPhysical< UnitSystem, T1, exponents1 > a, FixedPhysical< UnitSystem, T2, exponents2 > b)
template<class UnitSystem, typename T1, typename T2, class exponents>
bool operator== (const FixedPhysical< UnitSystem, T1, exponents > a, FixedPhysical< UnitSystem, T2, exponents > b)
template<class UnitSystem, typename T1, typename T2, class exponents>
bool operator!= (const FixedPhysical< UnitSystem, T1, exponents > a, FixedPhysical< UnitSystem, T2, exponents > b)
template<class UnitSystem, typename T1, typename T2, class exponents>
bool operator>= (const FixedPhysical< UnitSystem, T1, exponents > a, FixedPhysical< UnitSystem, T2, exponents > b)
template<class UnitSystem, typename T1, typename T2, class exponents>
bool operator<= (const FixedPhysical< UnitSystem, T1, exponents > a, FixedPhysical< UnitSystem, T2, exponents > b)
template<class UnitSystem, typename T1, typename T2, class exponents>
bool operator> (const FixedPhysical< UnitSystem, T1, exponents > a, FixedPhysical< UnitSystem, T2, exponents > b)
template<class UnitSystem, typename T1, typename T2, class exponents>
bool operator< (const FixedPhysical< UnitSystem, T1, exponents > a, FixedPhysical< UnitSystem, T2, exponents > b)
template<class UnitSystem, typename T1, typename T2, class exponents1>
FixedPhysical< UnitSystem,
typename detail::larger_type<
T1, T2 >::type, exponents1 > 		operator * (const T1 a, const FixedPhysical< UnitSystem, T2, exponents1 > b)

Function Documentation

template<class UnitSystem, typename T1, typename T2, class exponents1>
FixedPhysical<UnitSystem, typename detail::larger_type<T1, T2>::type, exponents1> physical::operator * ( const T1  a,
const FixedPhysical< UnitSystem, T2, exponents1 >  b 
)

Definition at line 179 of file fixedphysical.hpp.

00179                                                                                 {
00180                 typedef FixedPhysical<UnitSystem, typename detail::larger_type<T1, T2>::type, exponents1> return_type;
00181                 return return_type(a * b.numerical_value);
00182         };

template<class UnitSystem, typename T1, typename T2, class exponents1, class exponents2>
FixedPhysicalProduct< FixedPhysical<UnitSystem, T1, exponents1>, FixedPhysical<UnitSystem, T2, exponents2> >::type physical::operator * ( const FixedPhysical< UnitSystem, T1, exponents1 >  a,
FixedPhysical< UnitSystem, T2, exponents2 >  b 
)

Definition at line 111 of file fixedphysical.hpp.

00111                                                                                                                  {
00112                 typedef FixedPhysicalProduct<FixedPhysical<UnitSystem, T1, exponents1>, FixedPhysical<UnitSystem, T2, exponents2> >::type return_type;
00113                 return return_type(a.numerical_value * b.numerical_value);
00114         };

template<class UnitSystem>
DynamicPhysical< UnitSystem > physical::operator * ( double  real,
const DynamicUnit< UnitSystem > &  unit 
)

Definition at line 131 of file dynamicphysical_impl.hpp.

References physical::unitsymbol_si_float::unit.

00132         {
00133                 return DynamicPhysical<UnitSystem>(real*unit.scale.factor + unit.scale.origin, unit.exponents);
00134         };

template<class UnitSystem>
DynamicPhysical< UnitSystem > physical::operator * ( double  a,
DynamicPhysical< UnitSystem >  b 
)

Definition at line 56 of file dynamicphysical_impl.hpp.

References physical::DynamicPhysical< UnitSystem >::exponents, and physical::DynamicPhysical< UnitSystem >::numerical_value.

00056                                                            {
00057                 return DynamicPhysical<UnitSystem>(a*b.numerical_value, b.exponents);
00058         };

template<class UnitSystem>
DynamicPhysical< UnitSystem > physical::operator * ( DynamicPhysical< UnitSystem >  a,
DynamicPhysical< UnitSystem >  b 
)

Definition at line 50 of file dynamicphysical_impl.hpp.

References physical::DynamicPhysical< UnitSystem >::exponents, and physical::DynamicPhysical< UnitSystem >::numerical_value.

00050                                                                                 {
00051                 return DynamicPhysical<UnitSystem>(a.numerical_value*b.numerical_value, a.exponents+b.exponents);
00052         };

template<typename T1, typename T2, class exponents1>
FixedPhysical<typename detail::larger_type<T1, T2>::type, exponents1> physical::operator * ( const T1  a,
const FixedPhysical< T2, exponents1 >  b 
)

Definition at line 166 of file Copy of fixedphysical.hpp.

References physical::FixedPhysical< T, Exponents >::numerical_value.

00166                                                                     {
00167                 typedef FixedPhysical<typename detail::larger_type<T1, T2>::type, exponents1> return_type;
00168                 return return_type(a * b.numerical_value);
00169         };

template<typename T1, typename T2, class exponents1, class exponents2>
FixedPhysicalProduct< FixedPhysical<T1, exponents1>, FixedPhysical<T2, exponents2> >::type physical::operator * ( const FixedPhysical< T1, exponents1 >  a,
FixedPhysical< T2, exponents2 >  b 
)

Definition at line 98 of file Copy of fixedphysical.hpp.

References physical::FixedPhysical< T, Exponents >::numerical_value.

00098                                                                                          {
00099                 typedef FixedPhysicalProduct<FixedPhysical<T1, exponents1>, FixedPhysical<T2, exponents2> >::type return_type;
00100                 return return_type(a.numerical_value * b.numerical_value);
00101         };

template<class UnitSystem, typename T1, typename T2, class exponents>
bool physical::operator!= ( const FixedPhysical< UnitSystem, T1, exponents >  a,
FixedPhysical< UnitSystem, T2, exponents >  b 
)

Definition at line 133 of file fixedphysical.hpp.

00133                                                                                                                 {
00134                 return  retrun_type(a.numerical_value != b.numerical_value);
00135         };

template<class UnitSystem>
bool physical::operator!= ( DynamicPhysical< UnitSystem >  a,
DynamicPhysical< UnitSystem >  b 
)

Definition at line 78 of file dynamicphysical_impl.hpp.

References physical::DynamicPhysical< UnitSystem >::exponents.

00078                                                                                       {
00079                 if (a.exponents != b.exponents){
00080                         throw IncompatibleUnitException("cannot compare quantities with different dimensions");
00081                 };
00082                 return a!=b;
00083         };

template<typename T1, typename T2, class exponents>
bool physical::operator!= ( const FixedPhysical< T1, exponents >  a,
FixedPhysical< T2, exponents >  b 
)

Definition at line 120 of file Copy of fixedphysical.hpp.

References physical::FixedPhysical< T, Exponents >::numerical_value.

00120                                                                                         {
00121                 return  retrun_type(a.numerical_value != b.numerical_value);
00122         };

template<class UnitSystem, typename T1, typename T2, class exponents>
FixedPhysicalSum< FixedPhysical<UnitSystem, T1, exponents>, FixedPhysical<UnitSystem, T2, exponents> >::type physical::operator+ ( const FixedPhysical< UnitSystem, T1, exponents >  a,
FixedPhysical< UnitSystem, T2, exponents >  b 
)

Definition at line 97 of file fixedphysical.hpp.

00097                                                                                                                {
00098                 typedef FixedPhysicalSum<FixedPhysical<UnitSystem, T1, exponents>, FixedPhysical<UnitSystem, T2, exponents> >::type return_type;
00099                 return  retrun_type(a.numerical_value + b.numerical_value);
00100         };

template<class UnitSystem>
DynamicPhysical< UnitSystem > physical::operator+ ( DynamicPhysical< UnitSystem >  a,
DynamicPhysical< UnitSystem >  b 
)

Definition at line 33 of file dynamicphysical_impl.hpp.

References physical::DynamicPhysical< UnitSystem >::exponents, and physical::DynamicPhysical< UnitSystem >::numerical_value.

00033                                                                                 {
00034                 if (a.exponents != b.exponents) 
00035                         throw IncompatibleUnitException("cannot add quantities with different dimensions");
00036                 return DynamicPhysical<UnitSystem>(a.numerical_value+b.numerical_value, a.exponents);
00037         };

template<typename T1, typename T2, class exponents>
FixedPhysicalSum< FixedPhysical<T1, exponents>, FixedPhysical<T2, exponents> >::type physical::operator+ ( const FixedPhysical< T1, exponents >  a,
FixedPhysical< T2, exponents >  b 
)

Definition at line 84 of file Copy of fixedphysical.hpp.

References physical::FixedPhysical< T, Exponents >::numerical_value.

00084                                                                                        {
00085                 typedef FixedPhysicalSum<FixedPhysical<T1, exponents>, FixedPhysical<T2, exponents> >::type return_type;
00086                 return  retrun_type(a.numerical_value + b.numerical_value);
00087         };

template<class UnitSystem, typename T1, typename T2, class exponents>
FixedPhysicalSum< FixedPhysical<UnitSystem, T1, exponents>, FixedPhysical<UnitSystem, T2, exponents> >::type physical::operator- ( const FixedPhysical< UnitSystem, T1, exponents >  a,
FixedPhysical< UnitSystem, T2, exponents >  b 
)

Definition at line 104 of file fixedphysical.hpp.

00104                                                                                                                {
00105                 typedef FixedPhysicalSum<FixedPhysical<UnitSystem, T1, exponents>, FixedPhysical<UnitSystem, T2, exponents> >::type return_type;
00106                 return  retrun_type(a.numerical_value - b.numerical_value);
00107         };

template<class UnitSystem>
DynamicPhysical< UnitSystem > physical::operator- ( DynamicPhysical< UnitSystem >  a,
DynamicPhysical< UnitSystem >  b 
)

Definition at line 41 of file dynamicphysical_impl.hpp.

References physical::DynamicPhysical< UnitSystem >::exponents, and physical::DynamicPhysical< UnitSystem >::numerical_value.

00041                                                                                 {
00042                 if (a.exponents != b.exponents) 
00043                         throw IncompatibleUnitException("cannot substract quantities with different dimensions");
00044                 return DynamicPhysical<UnitSystem>(a.numerical_value-b.numerical_value, a.exponents);
00045         };

template<typename T1, typename T2, class exponents>
FixedPhysicalSum< FixedPhysical<T1, exponents>, FixedPhysical<T2, exponents> >::type physical::operator- ( const FixedPhysical< T1, exponents >  a,
FixedPhysical< T2, exponents >  b 
)

Definition at line 91 of file Copy of fixedphysical.hpp.

References physical::FixedPhysical< T, Exponents >::numerical_value.

00091                                                                                        {
00092                 typedef FixedPhysicalSum<FixedPhysical<T1, exponents>, FixedPhysical<T2, exponents> >::type return_type;
00093                 return  retrun_type(a.numerical_value - b.numerical_value);
00094         };

template<class UnitSystem, typename T1, typename T2, class exponents1, class exponents2>
FixedPhysicalRatio< FixedPhysical<UnitSystem, T1, exponents1>, FixedPhysical<UnitSystem, T2, exponents2> >::type physical::operator/ ( const FixedPhysical< UnitSystem, T1, exponents1 >  a,
FixedPhysical< UnitSystem, T2, exponents2 >  b 
)

Definition at line 118 of file fixedphysical.hpp.

00118                                                                                                                  {
00119                 typedef FixedPhysicalRatio<FixedPhysical<UnitSystem, T1, exponents1>, FixedPhysical<UnitSystem, T2, exponents2> >::type return_type;
00120                 return return_type(a.numerical_value / b.numerical_value);
00121         };

template<class UnitSystem>
DynamicPhysical< UnitSystem > physical::operator/ ( DynamicPhysical< UnitSystem >  quantity,
const DynamicUnit< UnitSystem >  unit 
)

Definition at line 138 of file dynamicphysical_impl.hpp.

References physical::unitsymbol_si_float::quantity, and physical::unitsymbol_si_float::unit.

00139         {
00140                 return DynamicPhysical<UnitSystem>((quantity.numerical_value - unit.scale.origin)/ unit.scale.factor, unit.exponents);
00141         };

template<class UnitSystem>
DynamicPhysical< UnitSystem > physical::operator/ ( DynamicPhysical< UnitSystem >  a,
DynamicPhysical< UnitSystem >  b 
)

Definition at line 63 of file dynamicphysical_impl.hpp.

References physical::DynamicPhysical< UnitSystem >::exponents, and physical::DynamicPhysical< UnitSystem >::numerical_value.

00063                                                                                 {
00064                 return DynamicPhysical<UnitSystem>(a.numerical_value / b.numerical_value, a.exponents-b.exponents);
00065         };

template<typename T1, typename T2, class exponents1, class exponents2>
FixedPhysicalRatio< FixedPhysical<T1, exponents1>, FixedPhysical<T2, exponents2> >::type physical::operator/ ( const FixedPhysical< T1, exponents1 >  a,
FixedPhysical< T2, exponents2 >  b 
)

Definition at line 105 of file Copy of fixedphysical.hpp.

References physical::FixedPhysical< T, Exponents >::numerical_value.

00105                                                                                          {
00106                 typedef FixedPhysicalRatio<FixedPhysical<T1, exponents1>, FixedPhysical<T2, exponents2> >::type return_type;
00107                 return return_type(a.numerical_value / b.numerical_value);
00108         };

template<class UnitSystem, typename T1, typename T2, class exponents>
bool physical::operator< ( const FixedPhysical< UnitSystem, T1, exponents >  a,
FixedPhysical< UnitSystem, T2, exponents >  b 
)

Definition at line 157 of file fixedphysical.hpp.

00157                                                                                                                {
00158                 return  retrun_type(a.numerical_value < b.numerical_value);
00159         };

template<class UnitSystem>
bool physical::operator< ( DynamicPhysical< UnitSystem >  a,
DynamicPhysical< UnitSystem >  b 
)

Definition at line 110 of file dynamicphysical_impl.hpp.

00110                                                                                      {
00111                 if (a.exponents != b.exponents){
00112                         throw IncompatibleUnitException("cannot compare quantities with different dimensions");
00113                 };
00114                 return a<b;
00115         };

template<typename T1, typename T2, class exponents>
bool physical::operator< ( const FixedPhysical< T1, exponents >  a,
FixedPhysical< T2, exponents >  b 
)

Definition at line 144 of file Copy of fixedphysical.hpp.

00144                                                                                        {
00145                 return  retrun_type(a.numerical_value < b.numerical_value);
00146         };

template<class UnitSystem>
std::ostream& physical::operator<< ( std::ostream &  os,
DynamicPhysical< UnitSystem >  q 
) [inline]

Definition at line 40 of file autoformat.hpp.

References physical::format::detail::automatic_quantity().

00040                                                                                              {
00041                         return format::detail::automatic_quantity(os, q);
00042                 };

template<class UnitSystem, typename T1, typename T2, class exponents>
bool physical::operator<= ( const FixedPhysical< UnitSystem, T1, exponents >  a,
FixedPhysical< UnitSystem, T2, exponents >  b 
)

Definition at line 145 of file fixedphysical.hpp.

00145                                                                                                                 {
00146                 return  retrun_type(a.numerical_value <= b.numerical_value);
00147         };

template<class UnitSystem>
bool physical::operator<= ( DynamicPhysical< UnitSystem >  a,
DynamicPhysical< UnitSystem >  b 
)

Definition at line 94 of file dynamicphysical_impl.hpp.

00094                                                                                       {
00095                 if (a.exponents != b.exponents){
00096                         throw IncompatibleUnitException("cannot compare quantities with different dimensions");
00097                 };
00098                 return a<=b;
00099         };

template<typename T1, typename T2, class exponents>
bool physical::operator<= ( const FixedPhysical< T1, exponents >  a,
FixedPhysical< T2, exponents >  b 
)

Definition at line 132 of file Copy of fixedphysical.hpp.

00132                                                                                         {
00133                 return  retrun_type(a.numerical_value <= b.numerical_value);
00134         };

template<class UnitSystem, typename T1, typename T2, class exponents>
bool physical::operator== ( const FixedPhysical< UnitSystem, T1, exponents >  a,
FixedPhysical< UnitSystem, T2, exponents >  b 
)

Definition at line 127 of file fixedphysical.hpp.

00127                                                                                                                 {
00128                 return  retrun_type(a.numerical_value == b.numerical_value);
00129         };

template<class UnitSystem>
bool physical::operator== ( DynamicPhysical< UnitSystem >  a,
DynamicPhysical< UnitSystem >  b 
)

Definition at line 70 of file dynamicphysical_impl.hpp.

References physical::DynamicPhysical< UnitSystem >::exponents.

00070                                                                                       {
00071                 if (a.exponents != b.exponents){
00072                         throw IncompatibleUnitException("cannot compare quantities with different dimensions");
00073                 };
00074                 return a==b;
00075         };

template<typename T1, typename T2, class exponents>
bool physical::operator== ( const FixedPhysical< T1, exponents >  a,
FixedPhysical< T2, exponents >  b 
)

Definition at line 114 of file Copy of fixedphysical.hpp.

References physical::FixedPhysical< T, Exponents >::numerical_value.

00114                                                                                         {
00115                 return  retrun_type(a.numerical_value == b.numerical_value);
00116         };

template<class UnitSystem, typename T1, typename T2, class exponents>
bool physical::operator> ( const FixedPhysical< UnitSystem, T1, exponents >  a,
FixedPhysical< UnitSystem, T2, exponents >  b 
)

Definition at line 151 of file fixedphysical.hpp.

00151                                                                                                                {
00152                 return  retrun_type(a.numerical_value > b.numerical_value);
00153         };

template<class UnitSystem>
bool physical::operator> ( DynamicPhysical< UnitSystem >  a,
DynamicPhysical< UnitSystem >  b 
)

Definition at line 102 of file dynamicphysical_impl.hpp.

References physical::DynamicPhysical< UnitSystem >::exponents.

00102                                                                                      {
00103                 if (a.exponents != b.exponents){
00104                         throw IncompatibleUnitException("cannot compare quantities with different dimensions");
00105                 };
00106                 return a>b;
00107         };

template<typename T1, typename T2, class exponents>
bool physical::operator> ( const FixedPhysical< T1, exponents >  a,
FixedPhysical< T2, exponents >  b 
)

Definition at line 138 of file Copy of fixedphysical.hpp.

References physical::FixedPhysical< T, Exponents >::numerical_value.

00138                                                                                        {
00139                 return  retrun_type(a.numerical_value > b.numerical_value);
00140         };

template<class UnitSystem, typename T1, typename T2, class exponents>
bool physical::operator>= ( const FixedPhysical< UnitSystem, T1, exponents >  a,
FixedPhysical< UnitSystem, T2, exponents >  b 
)

Definition at line 139 of file fixedphysical.hpp.

00139                                                                                                                 {
00140                 return  retrun_type(a.numerical_value >= b.numerical_value);
00141         };

template<class UnitSystem>
bool physical::operator>= ( DynamicPhysical< UnitSystem >  a,
DynamicPhysical< UnitSystem >  b 
)

Definition at line 86 of file dynamicphysical_impl.hpp.

References physical::DynamicPhysical< UnitSystem >::exponents.

00086                                                                                       {
00087                 if (a.exponents != b.exponents){
00088                         throw IncompatibleUnitException("cannot compare quantities with different dimensions");
00089                 };
00090                 return a>=b;
00091         };

template<typename T1, typename T2, class exponents>
bool physical::operator>= ( const FixedPhysical< T1, exponents >  a,
FixedPhysical< T2, exponents >  b 
)

Definition at line 126 of file Copy of fixedphysical.hpp.

References physical::FixedPhysical< T, Exponents >::numerical_value.

00126                                                                                         {
00127                 return  retrun_type(a.numerical_value >= b.numerical_value);
00128         };

template<class UnitSystem>
DynamicPhysical< UnitSystem > physical::power ( DynamicPhysical< UnitSystem >  a,
int  n 
)

Definition at line 120 of file dynamicphysical_impl.hpp.

00120                                                                                 {
00121                 DynamicPhysical r=1.;
00122                 while(n>0) {r=r*a; --n;};
00123                 while(n<0) {r=r/a; ++n;};
00124                 return r;
00125         };

Generated on Mon Apr 2 22:25:07 2007 for physical_svn by  doxygen 1.5.1-p1
hosted on SourceForge.net Logo