Main Page | Namespace List | Class Hierarchy | Class List | File List | Namespace Members | Class Members | File Members | Related Pages

quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU > Class Template Reference

constant quantities, specialization More...

#include <Constant.h>

List of all members.

Public Types

typedef unit::CheckUnit< unit::Unit<
BT >, SU >::Check 		Unit
 check SU and make the storage unit known as the Unit of the Constant


Public Member Functions

 Constant (void)
 default constructor

 Constant (const ST value)
 constructor

 Constant (const ST value, const SU &)
 constructor from same unit

template<class NU>  Constant (const ST value, const NU &)
 constructor from different unit

 Constant (const ST value, const std::string &symbol)
 constructor from different unit given by std::string

 Constant (const ST new_value, const char *symbol)
 constructor from different unit given by string constant

template<template< class, class > class Q1>  Constant (const Q1< PQ, SU > &quantity)
 copy constructor

template<template< class, class > class Q1, class SU1>  Constant (const Q1< PQ, SU1 > &quantity)
 copy constructor from quantity with different unit (conversion)

template<template< class, class > class Q1, class BT1, class DIM1, class DU1, class SU1>  Constant (const Q1< Quantity< DIM1, BT1, Loki::Typelist< unit::NonPrefixable< BT1, unit::GenericUnit >, Loki::NullType >, DU1, ST >, SU1 > &quantity)
 copy constructor from quantity with different unit (conversion)

 Constant (const Dynamic< ST > &dynamic)
 copy construction from Dynamic

ST value (void) const
 return the value in the storage unit;

ST standard_value (void) const
 return the value in the standard unit;

template<class NU> ST value (const unit::NonPrefixable< BT, NU > &) const
 return the value in a NonPrefixable unit NonPrefixable<BT, NU, ST>;

template<class NU, class P> ST value (const unit::Prefixed< unit::Prefixable< BT, NU >, P > &) const
 return the value in a Prefixed unit;

template<class CUL, class EL> ST value (const unit::Composed< unit::ComposeBase< BT, CUL >, EL > &) const
 return the value in a Composed unit;

ST value (const std::string &symbol)
 return the value in a unit with symbol string symbolstring;

template<class NU> Constant< PQ, NU > operator() (const NU &) const
 return the value in a Constant object with unit NU;

const std::string unitsymbol (void) const
 return the storage unit symbol;

const std::string unitname (void) const
 return the storage unit name;

Variable< PQ, SU > operator+ (void) const
 unary+ operator

Variable< PQ, SU > operator- (void) const
 unary- operator

template<class Q> Variable< PQ, SU > operator+ (const Q &new_variable) const
 binary operator+

template<class Q> Variable< PQ, SU > operator- (const Q &new_variable) const
 binary operator-

Variable< PQ, SU > operator * (const ST factor) const
 operator* for multiplication with ST

Variable< PQ, SU > operator/ (const ST factor) const
 operator/ for division by ST

bool operator== (const Constant &rhs_variable) const
 equality

template<template< class, class > class Q1, class SU1> bool operator== (const Q1< PQ, SU1 > &rhs_variable) const
 equality

template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1> bool operator== (const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1 > &rhs_variable) const
 equality

bool operator!= (const Constant &rhs_variable) const
 inequality

template<template< class, class > class Q1, class SU1> bool operator!= (const Q1< PQ, SU1 > &rhs_variable) const
 inequality

template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1> bool operator!= (const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1 > &rhs_variable) const
 inequality

bool operator> (const Constant &rhs_variable) const
 comparison: greater than

template<template< class, class > class Q1, class SU1> bool operator> (const Q1< PQ, SU1 > &rhs_variable) const
 comparison: greater than

template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1> bool operator> (const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1 > &rhs_variable) const
 comparison: greater than

bool operator< (const Constant &rhs_variable) const
 comparison: less than

template<template< class, class > class Q1, class SU1> bool operator< (const Q1< PQ, SU1 > &rhs_variable) const
 comparison: less than

template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1> bool operator< (const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1 > &rhs_variable) const
 comparison: less than

bool operator>= (const Constant &rhs_variable) const
 comparison: greater equal

template<template< class, class > class Q1, class SU1> bool operator>= (const Q1< PQ, SU1 > &rhs_variable) const
 comparison: greater equal

template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1> bool operator>= (const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1 > &rhs_variable) const
 comparison: greater equal

bool operator<= (const Constant &rhs_variable) const
 comparison: less equal

template<template< class, class > class Q1, class SU1> bool operator<= (const Q1< PQ, SU1 > &rhs_variable) const
 comparison: less equal

template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1> bool operator<= (const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1 > &rhs_variable) const
 comparison: less equal

template<class Q> GenerateVariable< Constant,
Q >::Add 		operator * (const Q &factor)
 multiplication of constant with a quantity

template<class Q> GenerateVariable< Constant,
Q >::Sub 		operator/ (const Q &factor)
 division of a constant by a quantity

template<long N, long D> GenerateVariable< Constant,
BSUtilities::Rational< N,
D > >::Mult 		pow (const BSUtilities::Rational< N, D > &)
 the alternative pow function with rational exponent

template<class T> Dynamic< ST > pow (const T &exp) const
 the alternative pow function with dynamic exponent

GenerateVariable< Constant,
BSUtilities::Rational<
1, 2 > >::Mult 		sqrt (void)
 the alternative sqrt function

std::ostream & print_value (std::ostream &os) const
 print the value and the unit of the constant

void operator>> (std::string &str) const
 store the value and unit of the variable in a std::string

std::ostream & operator>> (std::ostream &os) const
 print the variable


Static Public Member Functions

std::string Unitsymbol (void)
 return the storage unit symbol;

std::string Unitname (void)
 return the storage unit name;


Public Attributes

GenerateVariable< Constant,
BSUtilities::Rational< I,
long(1)> >::Mul 		pow )(typename Loki::Int2Type< I >)
 the alternative pow function with static integer exponent


Private Types

typedef dimension::Dimension<
BSUtilities::Rational< RL_N,
RL_D >, BSUtilities::Rational<
RM_N, RM_D >, BSUtilities::Rational<
RT_N, RT_D >, BSUtilities::Rational<
RE_N, RE_D >, BSUtilities::Rational<
RTE_N, RTE_D >, BSUtilities::Rational<
RA_N, RA_D >, BSUtilities::Rational<
RLU_N, RLU_D > > 		DIM
 the dimension

typedef Quantity< DIM, BT,
UL, DU, ST > 		PQ
 the parent quantity;


Private Member Functions

template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class ST1, class SU1> Constant & operator= (const Q1< Quantity< DIM1, BT1, UL1, DU1, ST1 >, SU1 > &)
 assignment to Constant from any Quantity

template<class TQ> Constant & operator= (const TQ &)
 assignment from other type


Private Attributes

ST constant_value
 the value of the Constant in the unit SU;


Friends

GenerateVariable< Constant,
Loki::NullType >::Inv 		operator/ (const ST numerator, const Constant &factor)
 division of a number by a constant

GenerateVariable< Constant,
BSUtilities::Rational<
1, 2 > >::Mult 		sqrt (const Constant &constant)
 the sqrt function

Detailed Description

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
class quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >

constant quantities, specialization

the parent quantity is required to be a Quantity, while there is no requirement on SU; the constant is derived from the parent quantity.

Definition at line 56 of file Constant.h.

Member Typedef Documentation

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
typedef dimension::Dimension<BSUtilities::Rational<RL_N, RL_D>, BSUtilities::Rational<RM_N, RM_D>, BSUtilities::Rational<RT_N, RT_D>, BSUtilities::Rational<RE_N, RE_D>, BSUtilities::Rational<RTE_N, RTE_D>, BSUtilities::Rational<RA_N, RA_D>, BSUtilities::Rational<RLU_N, RLU_D> > quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::DIM [private]
 

the dimension

make the dimension known as DIM

Definition at line 84 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
typedef Quantity<DIM, BT, UL, DU, ST> quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::PQ [private]
 

the parent quantity;

make the parent quantity known as PQ.

Definition at line 100 of file Constant.h.

Referenced by Constant().

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
typedef unit::CheckUnit<unit::Unit<BT>, SU>::Check quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::Unit
 

check SU and make the storage unit known as the Unit of the Constant

parameter SU is checked to be subclassed from Unit<BT>; this ensures that SU (a) is a unit, and (b) is connected to PQ through the base unit type BT.

Definition at line 93 of file Constant.h.

Referenced by Constant().

Member Function Documentation

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::Constant (  const Dynamic< ST > &  dynamic  )  [inline]
 

copy construction from Dynamic

this copy constructor has to do run-time checking of the dimensional information in Dynamic; division by the Gcd brings all components of the seven dimension Rationals in Constant to the canonical values.

Definition at line 240 of file Constant.h.

References quantity::Dynamic< ST >::_ra_d, quantity::Dynamic< ST >::_ra_n, quantity::Dynamic< ST >::_re_d, quantity::Dynamic< ST >::_re_n, quantity::Dynamic< ST >::_rl_d, quantity::Dynamic< ST >::_rl_n, quantity::Dynamic< ST >::_rlu_d, quantity::Dynamic< ST >::_rlu_n, quantity::Dynamic< ST >::_rm_d, quantity::Dynamic< ST >::_rm_n, quantity::Dynamic< ST >::_rt_d, quantity::Dynamic< ST >::_rt_n, quantity::Dynamic< ST >::_rte_d, quantity::Dynamic< ST >::_rte_n, and quantity::Dynamic< ST >::value().

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class BT1, class DIM1, class DU1, class SU1>
quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::Constant (  const Q1< Quantity< DIM1, BT1, Loki::Typelist< unit::NonPrefixable< BT1, unit::GenericUnit >, Loki::NullType >, DU1, ST >, SU1 > &  quantity  )  [inline]
 

copy constructor from quantity with different unit (conversion)

specialized version for a quantity derived from Quantity with a unit list typical for a generated quantity using a GenericUnit; this special case is the only exception when a quantity of different base unit type can be converted into the target Constant, provided the dimensions of the two objects are equal. This is tested with CheckSecondDimension.

Definition at line 219 of file Constant.h.

References PQ, and Unit.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class SU1>
quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::Constant (  const Q1< PQ, SU1 > &  quantity  )  [inline]
 

copy constructor from quantity with different unit (conversion)

specialized version for same parent quantity PQ; used if PQ of the target Constant to be constructed and that of the source quantity are identical; then we can be sure that the value of the source quantity can be recalculated into the unit of the target Constant; the result of this calculation is used in an initializer. The name and the symbol of the quantity are copied in the body of the function. The form of Q1<> must satisfy the template parameter sequence for a Constant or other classes similarly derived fom Quantity; this prohibits the conversion from general objects (string etc.).

Definition at line 202 of file Constant.h.

References PQ.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1>
quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::Constant (  const Q1< PQ, SU > &  quantity  )  [inline]
 

copy constructor

initialize the parent quantity PQ; then copy the value, the name and symbol string of new_constant;

Definition at line 183 of file Constant.h.

References PQ.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::Constant (  const ST  new_value,
const char *  symbol
)  [inline]
 

constructor from different unit given by string constant

takes a std:string defining the symbol of the unit as the second argument; the symbol is checked at run time for dynamic access; the value is first standardized on the base of the unit determined, and recalculated into the storage unit SU; first initializes base class; findBySymbol may throw a UnitMismatch exception.

Definition at line 167 of file Constant.h.

References PQ.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::Constant (  const ST  value,
const std::string &  symbol
)  [inline]
 

constructor from different unit given by std::string

takes a std:string defining the symbol of the unit as the second argument; the symbol is checked at run time for dynamic access; the value is first standardized on the base of the unit determined, and recalculated into the storage unit SU; first initializes base class; findBySymbol may throw a UnitMismatch exception.

Definition at line 149 of file Constant.h.

References PQ.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<class NU>
quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::Constant (  const ST  value,
const NU & 
)  [inline]
 

constructor from different unit

takes an instance of a unit of template parameter type NU as the second argument and recalculates the value into the storage unit SU; check that NU is listed in AllUnits; only the type NU is used; first initializes base class; Note: use only if NU is a concrete, not an abstract type.

Definition at line 135 of file Constant.h.

References PQ.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::Constant (  const ST  value,
const SU & 
)  [inline]
 

constructor from same unit

takes an instance of the storage unit as the second argument and uses value directly.

Definition at line 124 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::Constant (  const ST  value  )  [inline]
 

constructor

Set the value to new_value and assume this to be in storage unit SU.

Definition at line 118 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::Constant (  void   )  [inline]
 

default constructor

Set the value to 0 and assume this to be in storage unit SU.

Definition at line 113 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<class Q>
GenerateVariable<Constant, Q>::Add quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator * (  const Q &  factor  )  [inline]
 

multiplication of constant with a quantity

the type of the result is generated through GenerateVariable by adding the dimensions of the two quantities; only GenerateVariable with two quantities as arguments does have an Add typedef, thus, Q does not need to be specified.

Definition at line 671 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
Variable<PQ, SU> quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator * (  const ST  factor  )  const [inline]
 

operator* for multiplication with ST

generates new object; can be chained as in a * b * c;

Definition at line 428 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator!= (  const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1 > &  rhs_variable  )  const [inline]
 

inequality

compares to a right hand side operand being a general quantity; compares the values in the standard unit; to check dimension, the standardization call is generated through a compile time check; this should handle generated transient quantities as rhs argument.

Definition at line 506 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class SU1>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator!= (  const Q1< PQ, SU1 > &  rhs_variable  )  const [inline]
 

inequality

compares two objects of types from the same parent quantity PQ, but possibly different storage units SU and SU1; compares the values in the standard unit; we can be sure that values can be recalculated between SU and SU1;

Definition at line 493 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator!= (  const Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU > &  rhs_variable  )  const [inline]
 

inequality

compared objects of identical types; use value to retrieve the constant value of the right hand side Constant and directly compare to constant_value.

Definition at line 483 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<class NU>
Constant<PQ, NU> quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator() (  const NU &   )  const [inline]
 

return the value in a Constant object with unit NU;

Generates an object of the desired type and stores constant_value (which is in unit SU); recalculation occurs within the constructor of the new object. This is a conversion into another object with the new unit NU.

Definition at line 363 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<class Q>
Variable<PQ, SU> quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator+ (  const Q &  new_variable  )  const [inline]
 

binary operator+

can be chained as in a + b + c; forwards to addition to Variable

Definition at line 410 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
Variable<PQ, SU> quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator+ (  void   )  const [inline]
 

unary+ operator

returns a Variable object with the same dimension and other characteristics and same value.

Definition at line 391 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<class Q>
Variable<PQ, SU> quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator- (  const Q &  new_variable  )  const [inline]
 

binary operator-

can be chained as in a - b - c; forwards to addition to Variable

Definition at line 420 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
Variable<PQ, SU> quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator- (  void   )  const [inline]
 

unary- operator

returns a Variable object with the same dimension and other characteristics and same value with changed sign.

Definition at line 400 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<class Q>
GenerateVariable<Constant, Q>::Sub quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator/ (  const Q &  factor  )  [inline]
 

division of a constant by a quantity

the type of the result is generated through GenerateVariable by subtracting the dimensions of the two quantities; only GenerateVariable with two quantities as arguments does have an Sub typedef, thus, Q does not need to be specified.

Definition at line 685 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
Variable<PQ, SU> quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator/ (  const ST  factor  )  const [inline]
 

operator/ for division by ST

generates new object; can be chained as in a * b / c;

Definition at line 436 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator< (  const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1 > &  rhs_variable  )  const [inline]
 

comparison: less than

compares to a right hand side operand being a general quantity; compares the values in the standard unit; to check dimension, the standardization call is generated through a compile time check; this should handle generated transient quantities as rhs argument.

Definition at line 580 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class SU1>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator< (  const Q1< PQ, SU1 > &  rhs_variable  )  const [inline]
 

comparison: less than

compares two objects of types from the same parent quantity PQ, but possibly different storage units SU and SU1; compares the values in the standard unit; we can be sure that values can be recalculated between SU and SU1;

Definition at line 567 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator< (  const Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU > &  rhs_variable  )  const [inline]
 

comparison: less than

compared objects of identical types; use value to retrieve the constant value of the right hand side Constant and directly compare to constant_value.

Definition at line 557 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator<= (  const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1 > &  rhs_variable  )  const [inline]
 

comparison: less equal

compares to a right hand side operand being a general quantity; compares the values in the standard unit; to check dimension, the standardization call is generated through a compile time check; this should handle generated transient quantities as rhs argument.

Definition at line 654 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class SU1>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator<= (  const Q1< PQ, SU1 > &  rhs_variable  )  const [inline]
 

comparison: less equal

compares two objects of types from the same parent quantity PQ, but possibly different storage units SU and SU1; compares the values in the standard unit; we can be sure that values can be recalculated between SU and SU1;

Definition at line 641 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator<= (  const Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU > &  rhs_variable  )  const [inline]
 

comparison: less equal

compared objects of identical types; use value to retrieve the constant value of the right hand side Constant and directly compare to constant_value.

Definition at line 631 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<class TQ>
Constant& quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator= (  const TQ &   )  [private]
 

assignment from other type

only declaration, never defined and private in order to prevent assignment to a Constant

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class ST1, class SU1>
Constant& quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator= (  const Q1< Quantity< DIM1, BT1, UL1, DU1, ST1 >, SU1 > &   )  [private]
 

assignment to Constant from any Quantity

only declaration, never defined and private in order to prevent assignment to a Constant

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator== (  const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1 > &  rhs_variable  )  const [inline]
 

equality

compares to a right hand side operand being a general quantity; compares the values in the standard unit; to check dimension, the standardization call is generated through a compile time check; this should handle generated transient quantities as rhs argument.

Definition at line 469 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class SU1>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator== (  const Q1< PQ, SU1 > &  rhs_variable  )  const [inline]
 

equality

compares two objects of types from the same parent quantity PQ, but possibly different storage units SU and SU1; compares the values in the standard unit; we can be sure that values can be recalculated between SU and SU1;

Definition at line 456 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator== (  const Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU > &  rhs_variable  )  const [inline]
 

equality

compared objects of identical types; use value to retrieve the constant value of the right hand side Constant and directly compare to constant_value.

Definition at line 446 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator> (  const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1 > &  rhs_variable  )  const [inline]
 

comparison: greater than

compares to a right hand side operand being a general quantity; compares the values in the standard unit; to check dimension, the standardization call is generated through a compile time check; this should handle generated transient quantities as rhs argument.

Definition at line 543 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class SU1>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator> (  const Q1< PQ, SU1 > &  rhs_variable  )  const [inline]
 

comparison: greater than

compares two objects of types from the same parent quantity PQ, but possibly different storage units SU and SU1; compares the values in the standard unit; we can be sure that values can be recalculated between SU and SU1;

Definition at line 530 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator> (  const Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU > &  rhs_variable  )  const [inline]
 

comparison: greater than

compared objects of identical types; use value to retrieve the constant value of the right hand side Constant and directly compare to constant_value.

Definition at line 520 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator>= (  const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1 > &  rhs_variable  )  const [inline]
 

comparison: greater equal

compares to a right hand side operand being a general quantity; compares the values in the standard unit; to check dimension, the standardization call is generated through a compile time check; this should handle generated transient quantities as rhs argument.

Definition at line 617 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<template< class, class > class Q1, class SU1>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator>= (  const Q1< PQ, SU1 > &  rhs_variable  )  const [inline]
 

comparison: greater equal

compares two objects of types from the same parent quantity PQ, but possibly different storage units SU and SU1; compares the values in the standard unit; we can be sure that values can be recalculated between SU and SU1;

Definition at line 604 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
bool quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator>= (  const Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU > &  rhs_variable  )  const [inline]
 

comparison: greater equal

compared objects of identical types; use value to retrieve the constant value of the right hand side Constant and directly compare to constant_value.

Definition at line 594 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
std::ostream& quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator>> (  std::ostream &  os  )  const [inline]
 

print the variable

used if the variable is placed to the left of operator>>; calls print_value () indirectly through Quantity<>::print, thus including name and symbol of quantity if requested.

Definition at line 786 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
void quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::operator>> (  std::string &  str  )  const [inline]
 

store the value and unit of the variable in a std::string

converts to a string by template Conversion

Definition at line 778 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<class T>
Dynamic<ST> quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::pow (  const T &  exp  )  const [inline]
 

the alternative pow function with dynamic exponent

returns a transient Dynamic variable with the dimensions of the first argument multiplied by exp; alternative formulation; forwards action to pow function with quantity and dynamic exponent (friend functions in Dynamic for specific T's).

Definition at line 739 of file Constant.h.

References quantity::exp().

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<long N, long D>
GenerateVariable<Constant, BSUtilities::Rational<N, D> >::Mult quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::pow (  const BSUtilities::Rational< N, D > &   )  [inline]
 

the alternative pow function with rational exponent

returns a transient variable with the dimensions of the first argument multiplied by Rational<N, D>; used as object.pow (r); forwards action to pow function with quantity and rational exponent (in namespace Quantities).

Definition at line 714 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
std::ostream& quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::print_value (  std::ostream &  os  )  const [inline]
 

print the value and the unit of the constant

places these items on the ostream os and returns the reference to the os object, thus allowing chaining of operator<< calls.

Definition at line 772 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
GenerateVariable<Constant, BSUtilities::Rational<1, 2> >::Mult quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::sqrt (  void   )  [inline]
 

the alternative sqrt function

use as v.sqrt (), with v being an instantiation of a Constant

Definition at line 761 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
ST quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::standard_value (  void   )  const [inline]
 

return the value in the standard unit;

The stored constant_value is standardized using the Standardize () function for unit SU

Definition at line 293 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
std::string quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::Unitname (  void   )  [inline, static]
 

return the storage unit name;

the name is interrogated from SU; static access.

Definition at line 385 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
const std::string quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::unitname (  void   )  const [inline]
 

return the storage unit name;

the name is interrogated from SU; dynamic access.

Definition at line 380 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
std::string quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::Unitsymbol (  void   )  [inline, static]
 

return the storage unit symbol;

the symbol is interrogated from SU; static access.

Definition at line 375 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
const std::string quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::unitsymbol (  void   )  const [inline]
 

return the storage unit symbol;

the symbol is interrogated from SU; dynamic access.

Definition at line 369 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
ST quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::value (  const std::string &  symbol  )  [inline]
 

return the value in a unit with symbol string symbolstring;

The string is checked at run time, this allows dynamic access. The stored value is first standardized using the Standardize () function for unit SU, and then dynamically recalculated into the unit found with findBySymbol. The allocated object pointed to by unitp is deleted. If symbol is not found by findBySymbol, a UnitMismatch exception is thrown.

Definition at line 343 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<class CUL, class EL>
ST quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::value (  const unit::Composed< unit::ComposeBase< BT, CUL >, EL > &   )  const [inline]
 

return the value in a Composed unit;

The stored value is first standardized using the Standardize () function for unit SU, and then recalculated into the Composed, which is checked against AllUnits; only the type of the Composed is used.

Definition at line 329 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<class NU, class P>
ST quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::value (  const unit::Prefixed< unit::Prefixable< BT, NU >, P > &   )  const [inline]
 

return the value in a Prefixed unit;

The stored value is first standardized using the Standardize () function for unit SU, and then recalculated into the Prefixed, which is checked against AllUnits; only the type of the Prefixed is used.

Definition at line 316 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
template<class NU>
ST quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::value (  const unit::NonPrefixable< BT, NU > &   )  const [inline]
 

return the value in a NonPrefixable unit NonPrefixable<BT, NU, ST>;

The stored value is first standardized using the Standardize () function for unit SU, and then recalculated into the NonPrefixable, which is checked against AllUnits; only the type of the NonPrefixable is used.

Definition at line 303 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
ST quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::value (  void   )  const [inline]
 

return the value in the storage unit;

The stored constant_value is returned without recalculation.

Definition at line 287 of file Constant.h.

Friends And Related Function Documentation

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
GenerateVariable<Constant, Loki::NullType>::Inv operator/ (  const ST  numerator,
const Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU > &  factor
)  [friend]
 

division of a number by a constant

the type of the result is generated through GenerateVariable by negating the dimension of the variable;

Definition at line 697 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
GenerateVariable<Constant, BSUtilities::Rational<1, 2> >::Mult sqrt (  const Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU > &  constant  )  [friend]
 

the sqrt function

use as sqrt (v), with v being an instantiation of a Constant

Definition at line 749 of file Constant.h.

Member Data Documentation

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
ST quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::constant_value [private]
 

the value of the Constant in the unit SU;

This data member is private, and can only be accessed through the member functions value (); being set during construction of an object.

Definition at line 107 of file Constant.h.

template<long RL_N, long RL_D, long RM_N, long RM_D, long RT_N, long RT_D, long RE_N, long RE_D, long RTE_N, long RTE_D, long RA_N, long RA_D, long RLU_N, long RLU_D, class BT, class UL, class DU, class SU, class ST>
GenerateVariable<Constant, BSUtilities::Rational<I, long(1)> >::Mul quantity::Constant< Quantity< dimension::Dimension< BSUtilities::Rational< RL_N, RL_D >, BSUtilities::Rational< RM_N, RM_D >, BSUtilities::Rational< RT_N, RT_D >, BSUtilities::Rational< RE_N, RE_D >, BSUtilities::Rational< RTE_N, RTE_D >, BSUtilities::Rational< RA_N, RA_D >, BSUtilities::Rational< RLU_N, RLU_D > >, BT, UL, DU, ST >, SU >::pow)(typename Loki::Int2Type<I>) [inline]
 

the alternative pow function with static integer exponent

returns a transient variable with the dimensions of the first argument multiplied by I; used as object.pow (r); forwards action to pow function with quantity and static integer exponent (in namespace Quantities).

Definition at line 728 of file Constant.h.

The documentation for this class was generated from the following file:
Generated on Sun Jan 15 14:05:22 2006 for Quantity by doxygen 1.3.6