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

quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > > Class Template Reference

constant single instance quantities, specialization More...

#include <UniqueConstant.h>

List of all members.

Public 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 Loki::Typelist< NH,
NT > 		DDL
 the dedimensionalizer parameter type list type

typedef Loki::TL::TypeAt<
DDL, 0 >::Result 		DDP
 the parameters to the dedimensionalizing functor as a type

typedef Loki::Functor< R,
DDL > 		DD
 the dedimensionalizer type

typedef Quantity< DIM, BT,
UL, DU, ST > 		ABQ
 the abstract base quantity type

typedef UniqueConstant< ABQ,
SU, DD > 		UC
 the unique constant type

typedef ABQ PQ
 the parent quantity;

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

typedef BSUtilities::IF< BSUtilities::SameType<
DD, typename DefaultDedimensionalizer<
PQ, SU >::F >::sameType,
DedimReturn< PQ, SU >, UC
>::RET 		DDR
 the return variable type of dedimensionalizer


Public Member Functions

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> Variable< PQ, NU, DD > operator() (const NU &) const
 return the value in a Variable 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, DD > operator+ (void) const
 unary+ operator

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

template<class Q> Variable< PQ, SU > operator+ (const Q &new_variable) const
 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 right hand side multiplication with ST

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

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

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

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

bool operator== (const Dynamic< ST > &dynamic) const
 equality

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

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

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

bool operator!= (const Dynamic< ST > &dynamic) const
 inequality

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

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

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

bool operator> (const Dynamic< ST > &dynamic) const
 comparison: greater than

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

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

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

bool operator< (const Dynamic< ST > &dynamic) const
 comparison: less than

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

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

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

bool operator>= (const Dynamic< ST > &dynamic) const
 comparison: greater equal

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

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

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

bool operator<= (const Dynamic< ST > &dynamic) const
 comparison: less equal

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

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

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

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

GenerateVariable< UniqueConstant,
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 singleton 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

void save (BSUtilities::xmlw::XmlStream &os) const
 save contents of the unique constant quantity object as xml

void load (const TiXmlHandle node) const
 load contents of the unique constant quantity object from xml code


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< UniqueConstant,
BSUtilities::Rational< I,
long(1)> >::Mul 		pow )(const typename Loki::Int2Type< I >) const
 the pow function with static integer exponent


Static Public Attributes

const std::string MODE
 the xml UniqueConstant mode tag


Private Member Functions

 UniqueConstant (void)
 default constructor

 UniqueConstant (const UniqueConstant &new_constant)
 copy constructor


Static Private Member Functions

DDR defaultDedimensionalizer (DDP)
 the default dedimensionalizing function


Private Attributes

DD _dedimensionalizer
 the (de)dimensionalizing functor object

ST constant_value
 the value of the UniqueConstant in the storage unit;


Static Private Attributes

const DD _defaultDD
 the default dedimensionalizing functor

const ST default_value_
 the value of the UniqueConstant in the default unit;


Friends

class Loki::CreateUsingNew< UC >
 declare the default creation policy a friend

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

GenerateVariable< UniqueConstant,
BSUtilities::Rational<
1, 2 > >::Mult 		sqrt (const UniqueConstant &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 R, class NH, class NT>
class quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >

constant single instance 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 60 of file UniqueConstant.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, class R, class NH, class NT>
typedef Quantity<DIM, BT, UL, DU, ST> quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::ABQ
 

the abstract base quantity type

the Quantity which is used as the abstract base class for this quantity;

Definition at line 110 of file UniqueConstant.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, class R, class NH, class NT>
typedef Loki::Functor<R, DDL> quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::DD
 

the dedimensionalizer type

Definition at line 104 of file UniqueConstant.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, class R, class NH, class NT>
typedef Loki::Typelist<NH, NT> quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::DDL
 

the dedimensionalizer parameter type list type

Definition at line 92 of file UniqueConstant.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, class R, class NH, class NT>
typedef Loki::TL::TypeAt<DDL, 0>::Result quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::DDP
 

the parameters to the dedimensionalizing functor as a type

a (possibly inhomogenous) collection of values to be given to the dedimensionalizing functor upon a call to redimensionalize the DedimensionalizedVariable; this is extracted from the DDL typelist, which should have a single element, which is again a Loki::Tuple, containing the individual parameters

Definition at line 101 of file UniqueConstant.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, class R, class NH, class NT>
typedef BSUtilities::IF<BSUtilities::SameType <DD, typename DefaultDedimensionalizer<PQ, SU>::F>::sameType, DedimReturn<PQ, SU>, UC>::RET quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::DDR
 

the return variable type of dedimensionalizer

Definition at line 142 of file UniqueConstant.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, class R, class NH, class NT>
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::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::DIM
 

the dimension

make the dimension known as DIM

Definition at line 89 of file UniqueConstant.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, class R, class NH, class NT>
typedef ABQ quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::PQ
 

the parent quantity;

this is the quantity which is used to generate this quantity in template form as a parameter to the quantity mode; this is the same as the abstract base quantity;

Definition at line 122 of file UniqueConstant.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, class R, class NH, class NT>
typedef UniqueConstant<ABQ, SU, DD> quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::UC
 

the unique constant type

make the unique constant known as UC

Definition at line 115 of file UniqueConstant.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, class R, class NH, class NT>
typedef unit::CheckUnit<unit::Unit<BT>, SU>::Check quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::Unit
 

check SU and if ok, make the storage unit SU known as Unit

parameter SU is checked to be subclassed from Unit<BT>; this ensures that SU (a) is a unit, (b) is a descendant of Unit<BT>, and (c) can be instantiated; since CheckUnit returns the test unit, this is typedef'ed for further use.

Definition at line 137 of file UniqueConstant.h.

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, class R, class NH, class NT>
DDR quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::defaultDedimensionalizer (  DDP   )  [inline, static, private]
 

the default dedimensionalizing function

returns an unnamed object; used if no dedimensionalizer is given by the user; does not use any of the parameters in DDP, the returned object contains unity.

Definition at line 150 of file UniqueConstant.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, class R, class NH, class NT>
void quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::load (  const TiXmlHandle  node  )  const [inline]
 

load contents of the unique constant quantity object from xml code

use this is when attempting to input the contents of the unique constant quantity object through the Quantity ObjectFactory

Definition at line 976 of file UniqueConstant.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, class R, class NH, class NT>
template<class Q>
GenerateVariable<UniqueConstant, Q>::Add quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator * (  const Q &  factor  )  [inline]
 

multiplication of singleton 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 836 of file UniqueConstant.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, class R, class NH, class NT>
Variable<PQ, SU> quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator * (  const ST  factor  )  const [inline]
 

operator* for right hand side multiplication with ST

generates new object; can be chained as in a * b * c; result has default dedimensionalizer;

Definition at line 353 of file UniqueConstant.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, class R, class NH, class NT>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator!= (  const Dynamic< ST > &  dynamic  )  const [inline]
 

inequality

compares to a right hand side operand being a Dynamic; this is necessary since there is no copy construction (conversion) from Dynamic to UniqueConstant, thus, a separate function needs to be provided; compares the values in the standard unit; the dedimensionalizer is not considered for comparison;

Definition at line 493 of file UniqueConstant.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, class R, class NH, class NT>
template<template< class, class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1, class N1>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator!= (  const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1, N1 > &  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. the dedimensionalizer is not considered for comparison;

Definition at line 476 of file UniqueConstant.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, class R, class NH, class NT>
template<template< class, class, class > class Q1, class SU1, class N1>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator!= (  const Q1< PQ, SU1, N1 > &  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; the dedimensionalizer is not considered for comparison;

Definition at line 461 of file UniqueConstant.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, class R, class NH, class NT>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator!= (  const UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > > &  rhs_variable  )  const [inline]
 

inequality

compares objects of identical types; use value to retrieve the variable value of the right hand side UniqueConstant and directly compare to variable_value. the dedimensionalizer is not considered for comparison;

Definition at line 449 of file UniqueConstant.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, class R, class NH, class NT>
template<class NU>
Variable<PQ, NU, DD> quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator() (  const NU &   )  const [inline]
 

return the value in a Variable 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. The dedimensionalizer in the resulting object is identiacal to the dedimensionalizer of the unique constant.

Definition at line 286 of file UniqueConstant.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, class R, class NH, class NT>
template<class Q>
Variable<PQ, SU> quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator+ (  const Q &  new_variable  )  const [inline]
 

operator+

can be chained as in a + b + c; result has default dedimensionalizer;

Definition at line 333 of file UniqueConstant.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, class R, class NH, class NT>
Variable<PQ, SU, DD> quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator+ (  void   )  const [inline]
 

unary+ operator

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

Definition at line 314 of file UniqueConstant.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, class R, class NH, class NT>
template<class Q>
Variable<PQ, SU> quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator- (  const Q &  new_variable  )  const [inline]
 

binary operator-

can be chained as in a - b - c; result has default dedimensionalizer; forwards to addition to Variable

Definition at line 344 of file UniqueConstant.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, class R, class NH, class NT>
Variable<PQ, SU, DD> quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::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 323 of file UniqueConstant.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, class R, class NH, class NT>
template<class Q>
GenerateVariable<UniqueConstant, Q>::Sub quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator/ (  const Q &  factor  )  [inline]
 

division of a singleton 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 851 of file UniqueConstant.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, class R, class NH, class NT>
Variable<PQ, SU> quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator/ (  const ST  factor  )  const [inline]
 

operator/ for division by ST

generates new object; can be chained as in a * b / c; result has default dedimensionalizer;

Definition at line 362 of file UniqueConstant.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, class R, class NH, class NT>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator< (  const Dynamic< ST > &  dynamic  )  const [inline]
 

comparison: less than

compares to a right hand side operand being a Dynamic; this is necessary since there is no copy construction (conversion) from Dynamic to UniqueConstant, thus, a separate function needs to be provided; compares the values in the standard unit; the dedimensionalizer is not considered for comparison;

Definition at line 647 of file UniqueConstant.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, class R, class NH, class NT>
template<template< class, class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1, class N1>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator< (  const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1, N1 > &  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. the dedimensionalizer is not considered for comparison;

Definition at line 630 of file UniqueConstant.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, class R, class NH, class NT>
template<template< class, class, class > class Q1, class SU1, class N1>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator< (  const Q1< PQ, SU1, N1 > &  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; the dedimensionalizer is not considered for comparison;

Definition at line 615 of file UniqueConstant.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, class R, class NH, class NT>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator< (  const UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > > &  rhs_variable  )  const [inline]
 

comparison: less than

compares objects of identical types; use value to retrieve the variable value of the right hand side UniqueConstant and directly compare to variable_value. the dedimensionalizer is not considered for comparison;

Definition at line 603 of file UniqueConstant.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, class R, class NH, class NT>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator<= (  const Dynamic< ST > &  dynamic  )  const [inline]
 

comparison: less equal

compares to a right hand side operand being a Dynamic; this is necessary since there is no copy construction (conversion) from Dynamic to UniqueConstant, thus, a separate function needs to be provided; compares the values in the standard unit; the dedimensionalizer is not considered for comparison;

Definition at line 801 of file UniqueConstant.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, class R, class NH, class NT>
template<template< class, class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1, class N1>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator<= (  const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1, N1 > &  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. the dedimensionalizer is not considered for comparison;

Definition at line 784 of file UniqueConstant.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, class R, class NH, class NT>
template<template< class, class, class > class Q1, class SU1, class N1>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator<= (  const Q1< PQ, SU1, N1 > &  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; the dedimensionalizer is not considered for comparison;

Definition at line 769 of file UniqueConstant.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, class R, class NH, class NT>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator<= (  const UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > > &  rhs_variable  )  const [inline]
 

comparison: less equal

compares objects of identical types; use value to retrieve the variable value of the right hand side UniqueConstant and directly compare to variable_value. the dedimensionalizer is not considered for comparison;

Definition at line 757 of file UniqueConstant.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, class R, class NH, class NT>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator== (  const Dynamic< ST > &  dynamic  )  const [inline]
 

equality

compares to a right hand side operand being a Dynamic; this is necessary since there is no copy construction (conversion) from Dynamic to UniqueConstant, thus, a separate function needs to be provided; compares the values in the standard unit; the dedimensionalizer is not considered for comparison;

Definition at line 416 of file UniqueConstant.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, class R, class NH, class NT>
template<template< class, class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1, class N1>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator== (  const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1, N1 > &  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. the dedimensionalizer is not considered for comparison;

Definition at line 399 of file UniqueConstant.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, class R, class NH, class NT>
template<template< class, class, class > class Q1, class SU1, class N1>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator== (  const Q1< PQ, SU1, N1 > &  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; the dedimensionalizer is not considered for comparison;

Definition at line 384 of file UniqueConstant.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, class R, class NH, class NT>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator== (  const UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > > &  rhs_variable  )  const [inline]
 

equality

compares objects of identical types; use value to retrieve the variable value of the right hand side Constant and directly compare to variable_value.

Definition at line 372 of file UniqueConstant.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, class R, class NH, class NT>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator> (  const Dynamic< ST > &  dynamic  )  const [inline]
 

comparison: greater than

compares to a right hand side operand being a Dynamic; this is necessary since there is no copy construction (conversion) from Dynamic to UniqueConstant, thus, a separate function needs to be provided; compares the values in the standard unit; the dedimensionalizer is not considered for comparison;

Definition at line 570 of file UniqueConstant.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, class R, class NH, class NT>
template<template< class, class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1, class N1>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator> (  const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1, N1 > &  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. the dedimensionalizer is not considered for comparison;

Definition at line 553 of file UniqueConstant.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, class R, class NH, class NT>
template<template< class, class, class > class Q1, class SU1, class N1>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator> (  const Q1< PQ, SU1, N1 > &  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; the dedimensionalizer is not considered for comparison;

Definition at line 538 of file UniqueConstant.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, class R, class NH, class NT>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator> (  const UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > > &  rhs_variable  )  const [inline]
 

comparison: greater than

compares objects of identical types; use value to retrieve the variable value of the right hand side UniqueConstant and directly compare to variable_value. the dedimensionalizer is not considered for comparison;

Definition at line 526 of file UniqueConstant.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, class R, class NH, class NT>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator>= (  const Dynamic< ST > &  dynamic  )  const [inline]
 

comparison: greater equal

compares to a right hand side operand being a Dynamic; this is necessary since there is no copy construction (conversion) from Dynamic to UniqueConstant, thus, a separate function needs to be provided; compares the values in the standard unit; the dedimensionalizer is not considered for comparison;

Definition at line 724 of file UniqueConstant.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, class R, class NH, class NT>
template<template< class, class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1, class N1>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator>= (  const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1, N1 > &  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. the dedimensionalizer is not considered for comparison;

Definition at line 707 of file UniqueConstant.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, class R, class NH, class NT>
template<template< class, class, class > class Q1, class SU1, class N1>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator>= (  const Q1< PQ, SU1, N1 > &  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; the dedimensionalizer is not considered for comparison;

Definition at line 692 of file UniqueConstant.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, class R, class NH, class NT>
bool quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::operator>= (  const UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > > &  rhs_variable  )  const [inline]
 

comparison: greater equal

compares objects of identical types; use value to retrieve the variable value of the right hand side UniqueConstant and directly compare to variable_value. the dedimensionalizer is not considered for comparison;

Definition at line 680 of file UniqueConstant.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, class R, class NH, class NT>
std::ostream& quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::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 956 of file UniqueConstant.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, class R, class NH, class NT>
void quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::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 948 of file UniqueConstant.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, class R, class NH, class NT>
template<class T>
Dynamic<ST> quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::pow (  const T &  exp  )  const [inline]
 

the pow function with dynamic exponent

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

Definition at line 906 of file UniqueConstant.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, class R, class NH, class NT>
template<long N, long D>
GenerateVariable<UniqueConstant, BSUtilities::Rational<N, D> >::Mult quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::pow (  const BSUtilities::Rational< N, D > &   )  const [inline]
 

the pow function with rational exponent

returns a transient variable with the dimension of the first argument multiplied by Rational<N, D>; standardized value to be used, since the transient variable assumes a standardization factor of unity. used as object.pow (r);

Definition at line 881 of file UniqueConstant.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, class R, class NH, class NT>
std::ostream& quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::print_value (  std::ostream &  os  )  const [inline]
 

print the value and the unit of the singleton 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 942 of file UniqueConstant.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, class R, class NH, class NT>
void quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::save (  BSUtilities::xmlw::XmlStream &  os  )  const [inline]
 

save contents of the unique constant quantity object as xml

this should be used when attempting to output the contents of the unique constant quantity object in xml form, which can later be read without knowledge of the object's type

Definition at line 964 of file UniqueConstant.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, class R, class NH, class NT>
GenerateVariable<UniqueConstant, BSUtilities::Rational<1, 2> >::Mult quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::sqrt (  void   )  [inline]
 

the alternative sqrt function

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

Definition at line 930 of file UniqueConstant.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, class R, class NH, class NT>
ST quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::standard_value (  void   )  const [inline]
 

return the value in the standard unit;

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

Definition at line 215 of file UniqueConstant.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, class R, class NH, class NT>
quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::UniqueConstant (  const UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > > &  new_constant  )  [inline, private]
 

copy constructor

initialize parent quantity PQ; then copy the value, the name and symbol string of new_constant private for singleton to avoid sneaky copy, thus, cannot be called.

Definition at line 198 of file UniqueConstant.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, class R, class NH, class NT>
quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::UniqueConstant (  void   )  [inline, private]
 

default constructor

assume the value to be in the storage unit; private for singleton to avoid sneaky construction; construction possible through friend class CreateUsingNew<>. Construction from other units is not possible, i.e. the value MUST be given in the storage unit; assume default dedimensionalizer.

Definition at line 189 of file UniqueConstant.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, class R, class NH, class NT>
std::string quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::Unitname (  void   )  [inline, static]
 

return the storage unit name;

the name is interrogated from SU; static access.

Definition at line 308 of file UniqueConstant.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, class R, class NH, class NT>
const std::string quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::unitname (  void   )  const [inline]
 

return the storage unit name;

the name is interrogated from SU; dynamic access.

Definition at line 303 of file UniqueConstant.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, class R, class NH, class NT>
std::string quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::Unitsymbol (  void   )  [inline, static]
 

return the storage unit symbol;

the symbol is interrogated from SU; static access.

Definition at line 298 of file UniqueConstant.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, class R, class NH, class NT>
const std::string quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::unitsymbol (  void   )  const [inline]
 

return the storage unit symbol;

the symbol is interrogated from SU; dynamic access.

Definition at line 292 of file UniqueConstant.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, class R, class NH, class NT>
ST quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::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 265 of file UniqueConstant.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, class R, class NH, class NT>
template<class CUL, class EL>
ST quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::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 251 of file UniqueConstant.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, class R, class NH, class NT>
template<class NU, class P>
ST quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::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 238 of file UniqueConstant.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, class R, class NH, class NT>
template<class NU>
ST quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::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 Prefixable is used.

Definition at line 225 of file UniqueConstant.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, class R, class NH, class NT>
ST quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::value (  void   )  const [inline]
 

return the value in the storage unit;

The stored value is returned without recalculation.

Definition at line 209 of file UniqueConstant.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, class R, class NH, class NT>
friend class Loki::CreateUsingNew< UC > [friend]
 

declare the default creation policy a friend

necessary to allow private default constructor; CreateUsingNew is part of Alexandrescu's Loki library.

Definition at line 128 of file UniqueConstant.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, class R, class NH, class NT>
GenerateVariable<UniqueConstant, Loki::NullType>::Inv operator/ (  const ST  numerator,
const UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > > &  factor
)  [friend]
 

division of a number by a singleton constant

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

Definition at line 864 of file UniqueConstant.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, class R, class NH, class NT>
GenerateVariable<UniqueConstant, BSUtilities::Rational<1, 2> >::Mult sqrt (  const UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > > &  constant  )  [friend]
 

the sqrt function

use as sqrt (v), with v being an singleton constant

Definition at line 916 of file UniqueConstant.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, class R, class NH, class NT>
DD quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::_dedimensionalizer [private]
 

the (de)dimensionalizing functor object

the _dedimensionalizer object is a functor which returns an object to be used to perform the dedimensionalization of an object of type UC (by division) or the redimensionalization of the internally stored value into an object of type UC. Thus, _dedimensionalizer stores the recipe how to (de)dimensionalize the value stored in the DedimensionalizedVariable object.

Definition at line 166 of file UniqueConstant.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, class R, class NH, class NT>
const DD quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::_defaultDD [static, private]
 

the default dedimensionalizing functor

initialized outside of class to defaultDedimensionalizer

Definition at line 155 of file UniqueConstant.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, class R, class NH, class NT>
ST quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::constant_value [private]
 

the value of the UniqueConstant in the storage unit;

This data member is private, and can only be accessed through the member functions value ().

Definition at line 179 of file UniqueConstant.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, class R, class NH, class NT>
const ST quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::default_value_ [static, private]
 

the value of the UniqueConstant in the default unit;

This data member is private, and can only be accessed through the member functions value (); must be defined outside of class as a specialization for each UniqueConstant<PQ, SU>.

Definition at line 173 of file UniqueConstant.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, class R, class NH, class NT>
const std::string quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::MODE [static]
 

the xml UniqueConstant mode tag

define outside of class

Definition at line 1004 of file UniqueConstant.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, class R, class NH, class NT>
GenerateVariable<UniqueConstant, BSUtilities::Rational<I, long(1)> >::Mul quantity::UniqueConstant< 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, Loki::Functor< R, Loki::Typelist< NH, NT > > >::pow)(const typename Loki::Int2Type<I>) const [inline]
 

the pow function with static integer exponent

returns a transient variable with the dimensions of the first argument multiplied by I; standardized value to be used, since the transient variable assumes a standardization factor of unity. used as object.pow (r);

Definition at line 895 of file UniqueConstant.h.

The documentation for this class was generated from the following file:
Generated on Mon Feb 12 18:44:00 2007 for Quantity by doxygen 1.3.6