#include <Variable.h>
Public Types | |
| typedef Quantity< DIM, BT, UL, DU, ST > | 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 | |
Public Member Functions | |
| Variable (void) | |
| default constructor | |
| Variable (const ST value) | |
| constructor | |
| Variable (const ST value, const SU &) | |
| constructor from same unit | |
| template<class NU> | Variable (const ST value, const NU &) |
| constructor from different unit | |
| Variable (const ST value, const std::string &symbol) | |
| constructor from different unit given by std::string | |
| Variable (const ST value, const char *symbol) | |
| constructor from different unit given by string constant | |
| template<template< class, class > class Q1> | Variable (const Q1< PQ, SU > &quantity) |
| copy constructor | |
| template<template< class, class > class Q1, class SU1> | Variable (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> | Variable (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) | |
| template<template< class, class > class Q1, class PQ1, class SU1> | Variable (const Q1< PQ1, SU1 > &) |
| copy constructor from some other quantity Q1 | |
| Variable (const Dynamic< ST > &dynamic) | |
| copy construction from Dynamic | |
| Variable & | operator= (const Variable &new_variable) |
| assignment operator | |
| template<template< class, class > class Q1, class SU1> Variable & | operator= (const Q1< PQ, SU1 > &quantity) |
| assignment operator | |
| template<template< class, class > class Q1, class PQ1, class SU1> Variable & | operator= (const Q1< PQ1, SU1 > &quantity) |
| assignment operator | |
| template<template< class, class > class Q1, class BT1, class DIM1, class DU1, class SU1> Variable & | operator= (const Q1< Quantity< DIM1, BT1, Loki::Typelist< unit::NonPrefixable< BT1, unit::GenericUnit >, Loki::NullType >, DU1, ST >, SU1 > &quantity) |
| assignment operator | |
| Variable & | operator= (const Dynamic< ST > &dynamic) |
| assignment 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>; | |
| 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 > | 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 & | operator+= (const Variable &variable) |
| operator+= | |
| template<template< class, class > class Q1, class SU1> Variable & | operator+= (const Q1< PQ, SU1 > &quantity) |
| operator+= | |
| template<template< class, class > class Q1, class BT1, class DIM1, class DU1, class SU1> Variable & | operator+= (const Q1< Quantity< DIM1, BT1, Loki::Typelist< unit::NonPrefixable< BT1, unit::GenericUnit >, Loki::NullType >, DU1, ST >, SU1 > &quantity) |
| operator+= | |
| template<template< class, class > class Q1, class PQ1, class SU1> Variable & | operator+= (const Q1< PQ1, SU1 > &quantity) |
| operator+= | |
| Variable & | operator-= (const Variable &new_variable) |
| operator-= | |
| template<template< class, class > class Q1, class SU1> Variable & | operator-= (const Q1< PQ, SU1 > &quantity) |
| operator-= | |
| template<template< class, class > class Q1, class BT1, class DIM1, class DU1, class SU1> Variable & | operator-= (const Q1< Quantity< DIM1, BT1, Loki::Typelist< unit::NonPrefixable< BT1, unit::GenericUnit >, Loki::NullType >, DU1, ST >, SU1 > &quantity) |
| operator-= | |
| template<template< class, class > class Q1, class PQ1, class SU1> Variable & | operator-= (const Q1< PQ1, SU1 > &quantity) |
| operator-= | |
| Variable & | operator *= (const ST factor) |
| operator*= for multiplication with ST and assignment | |
| Variable & | operator/= (const ST divisor) |
| operator/= for division by ST and assignment | |
| Variable | operator+ (void) const |
| unary operator+ | |
| Variable | operator- (void) const |
| unary operator- | |
| template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1> Variable | operator+ (const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1 > &quantity) const |
| binary operator+ | |
| Variable | operator+ (const Dynamic< ST > &quantity) const |
| binary operator+ | |
| template<template< class, class > class Q1, class DIM1, class BT1, class UL1, class DU1, class SU1> Variable | operator- (const Q1< Quantity< DIM1, BT1, UL1, DU1, ST >, SU1 > &quantity) const |
| binary operator- | |
| Variable | operator- (const Dynamic< ST > &quantity) const |
| binary operator- | |
| Variable | operator * (const ST factor) const |
| operator* for right hand multiplication with ST | |
| Variable | operator/ (const ST divisor) const |
| operator/ for division by ST | |
| bool | operator== (const Variable &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 Variable &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 Variable &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 Variable &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 Variable &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 Variable &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< Variable, Q >::Add | operator * (const Q &factor) const |
| multiplication of variables with a quantity | |
| template<class Q> GenerateVariable< Variable, Q >::Sub | operator/ (const Q &factor) const |
| division of a variable by a quantity | |
| template<long N, long D> GenerateVariable< Variable, 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< Variable, BSUtilities::Rational< 1, 2 > >::Mult | sqrt (void) const |
| the alternative sqrt function | |
| std::ostream & | print_value (std::ostream &os) const |
| print the value and the unit of the variable | |
| 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 | read_value (const std::string &str) |
| read variable value and unit from a string | |
| void | operator<< (const std::string &str) |
| read from string to the right of operator<< | |
| void | operator= (const std::string &str) |
| assign from a string | |
| std::istream & | operator<< (std::istream &is) |
| read from a std::istream to the right of operator<< | |
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< Variable, BSUtilities::Rational< I, long(1)> >::Mul | pow )(typename Loki::Int2Type< I >) |
| the alternative pow function with static integer exponent | |
Protected Attributes | |
| ST | variable_value |
| the value of the Variable in the storage unit | |
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 | |
Friends | |
| template<template< class, class > class Q> Variable | operator+ (const Dynamic< ST > &quantity1, const Q< Quantity< DIM, BT, UL, DU, ST >, SU > &quantity2) |
| binary operator+ | |
| template<template< class, class > class Q> Variable | operator- (const Dynamic< ST > &quantity1, const Q< Quantity< DIM, BT, UL, DU, ST >, SU > &quantity2) |
| binary operator- | |
| template<template< class, class > class Q1> Variable | operator * (const ST factor, const Q1< PQ, SU > &variable) |
| operator* for left hand multiplication by ST | |
| GenerateVariable< Variable, Loki::NullType >::Inv | operator/ (const ST numerator, const Variable &factor) |
| division of a number by a variable | |
| GenerateVariable< Variable, BSUtilities::Rational< 1, 2 > >::Mult | sqrt (const Variable &variable) |
| the sqrt function | |
| void | operator>> (const std::string &str, Variable &variable) |
| read from string to the left of operator>> | |
| std::istream & | operator>> (std::istream &is, Variable &variable) |
| read from a std::istream to the left of operator>> | |
the parent quantity is required to be a Quantity, while there is no requirement on SU; the variable is derived from the parent quantity.
Definition at line 203 of file Variable.h.
|
|||||
|
the dimension make the dimension known as DIM Definition at line 230 of file Variable.h. |
|
|||||
|
the parent quantity; make the parent quantity known as PQ. it is used by other classes, thus MUST be public Definition at line 237 of file Variable.h. |
|
|||||
|
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 connected to PQ through the base unit type BT, and (c) can be instantiated; since CheckUnit returns the test unit, this is typedef'ed for further use. Definition at line 246 of file Variable.h. |
|
||||||||||||||
|
multiplication of variables 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 1271 of file Variable.h. |
|
||||||||||
|
operator* for right hand multiplication with ST generates new object; can be chained as in a * b * c; Definition at line 1012 of file Variable.h. |
|
||||||||||
|
operator*= for multiplication with ST and assignment only right hand side ST makes sense, since the product can not be assigned to a ST in general Definition at line 821 of file Variable.h. |
|
||||||||||||||
|
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 1106 of file Variable.h. |
|
||||||||||||||
|
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 1093 of file Variable.h. |
|
||||||||||
|
inequality compares identical types; use value to retrieve the variabler value of the right hand side Variable and directly compare to variable_value. Definition at line 1083 of file Variable.h. |
|
||||||||||||||
|
return the value in a Variable object with unit NU; Generates an object of the desired type and stores variable_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 636 of file Variable.h. |
|
||||||||||
|
binary operator+ handles the case of addition of a Dynamic object on the right hand side of the operator; this is converted into an object of the left hand side type; this is only successful at run time, if the Dynamic object is commensurate; failure is indicated by a DimensionMismatch exception; finally addition is forwarded to the `generic' addition operator above. Definition at line 908 of file Variable.h. |
|
||||||||||||||
|
binary operator+ takes any left hand side quantity object and decides (at compile time) which of the helper structure static exec member functions should be used, based on the type of the unit of the left hand side object, i.e. if this is typical for a generated quantity object or not. Definition at line 889 of file Variable.h. |
|
||||||||||
|
unary operator+ returns a new object of same type and same value. Definition at line 839 of file Variable.h. |
|
||||||||||||||
|
operator+= specialization for two quantities from different parent quantities where the second is NOT a generated quantity; should never compile, but rather yield a DimensionError<true> compiler error message. Return is only for syntactic correctness. Definition at line 731 of file Variable.h. |
|
||||||||||||||
|
operator+= can be chained as in a += b += c; for a right hand side operand which is a generated quantity having a generic unit and the same dimension as the left hand side operand; value of both operands recalculated into standard unit, reverse standardization of the result before stored in variable_value. Definition at line 710 of file Variable.h. |
|
||||||||||||||
|
operator+= can be chained as in a += b += c; for quantities related through the same parent quantity and different storage unit; dimension is not checked, since the above ensures that they must be the same; value of both operands recalculated into standard unit, reverse standardization of the result before stored in variable_value. Definition at line 694 of file Variable.h. |
|
||||||||||
|
operator+= can be chained as in a += b += c; for two identical Variables; dimension is not checked, since the above ensures that they must be the same; on the other hand, in order to avoid assignment to a generated quantity object, it is checked if the unit list UL of the Variable is the same type as that of a unit list of a generated quantity, i.e. the left hand side quantity object is a generated quantity object. If this is the case, the compiler tries to instantiate AssignmentError<true>, which is not defined. Thus, a compiler error message occurs. If UL is different, AssignmentError<false>::RET is true, and the += operation is performed. Definition at line 675 of file Variable.h. |
|
||||||||||
|
binary operator- handles the case of addition of a Dynamic object on the right hand side of the operator; this is converted into an object of the left hand side type; this is only successful, of the Dynamic object is commensurate; finally addition is forwarded to the `generic' addition operator above. Definition at line 988 of file Variable.h. |
|
||||||||||||||
|
binary operator- takes any left hand side quantity object and decides (at compile time) which of the helper structure static exec member functions should be used, based on the type of the unit of the left hand side object, i.e. if this is typical for a generated quantity object or not. Definition at line 970 of file Variable.h. |
|
||||||||||
|
unary operator- returns a new object of same type and same value with changed sign. Definition at line 845 of file Variable.h. |
|
||||||||||||||
|
operator-= specialization for two quantities from different parent quantities where the second is NOT a generated quantity; should never compile, but rather yield a DimensionError<true> compiler error message Definition at line 809 of file Variable.h. |
|
||||||||||||||
|
operator-= can be chained as in a -= b -= c; for a right hand side operand which is a generated quantity having a generic unit and the same dimension as the left hand side operand; value of both operands recalculated into standard unit, reverse standardization of the result before stored in variable_value. Definition at line 789 of file Variable.h. |
|
||||||||||||||
|
operator-= can be chained as in a -= b -= c; for quantities related through the same parent quantity and different storage unit; dimension is not checked, since the above ensures that they must be the same; value of both operands recalculated into standard unit, reverse standardization of the result before stored in variable_value. Definition at line 773 of file Variable.h. |
|
||||||||||
|
operator-= can be chained as in a -= b -= c; for two identical Variables; dimension is not checked, since the above ensures that they must be the same; on the other hand, in order to avoid assignment to a generated quantity object, it is checked if the unit list UL of the Variable is the same type as that of a unit list of a generated quantity, i.e. the left hand side quantity object is a generated quantity object. If this is the case, the compiler tries to instantiate AssignmentError<true>, which is not defined. Thus, a compiler error message occurs. If UL is different, AssignmentError<false>::RET is true, and the -= operation is performed. Definition at line 754 of file Variable.h. |
|
||||||||||||||
|
division of a variable 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 1285 of file Variable.h. |
|
||||||||||
|
operator/ for division by ST generates new object; can be chained as in a * b / c; Definition at line 1020 of file Variable.h. |
|
||||||||||
|
operator/= for division by ST and assignment only right hand side ST makes sense, since the result of this operation with a left hand side ST can not be assigned to a ST in general Definition at line 831 of file Variable.h. |
|
||||||||||||||
|
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 1180 of file Variable.h. |
|
||||||||||||||
|
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 1167 of file Variable.h. |
|
||||||||||
|
comparison: less than compares identical types; use value to retrieve the variabler value of the right hand side Variable and directly compare to variable_value. Definition at line 1157 of file Variable.h. |
|
||||||||||
|
read from a std::istream to the right of operator<< creates an intermediary string into which the data are read which are subsequently interpreted with read_value; the reference to the istream object is returned to allow chaining. Definition at line 1410 of file Variable.h. |
|
||||||||||
|
read from string to the right of operator<<
Definition at line 1400 of file Variable.h. |
|
||||||||||||||
|
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 1254 of file Variable.h. |
|
||||||||||||||
|
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 1241 of file Variable.h. |
|
||||||||||
|
comparison: less equal compares identical types; use value to retrieve the variabler value of the right hand side Variable and directly compare to variable_value. Definition at line 1231 of file Variable.h. |
|
||||||||||
|
assign from a string
Definition at line 1403 of file Variable.h. |
|
||||||||||
|
assignment from Dynamic this assignment operator has to do run-time checking of the dimensional information in Dynamic! Definition at line 540 of file Variable.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(). |
|
||||||||||||||
|
assignment operator 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 BT can be assigned to the target Variable, provided the dimensions of the two objects are equal. This is tested with CheckSecondDimension. The form of Q1<> must satisfy the template parameter sequence for a Variable (or a other classes similarly derived fom Quantity); this prohibits assignment from general objects (strings etc.); comparison against self-assignment must be performed through void *, since &Q1 might be a pointer to a class different from that pointed to by this; thus, it is checked that the adresses of the two objects differ; the raw value of the source_quantity is extracted, converted into the unit of the present object, and the result is stored; only the variable_value is assigned, name and symbol of the present variable are not touched. It is assumed that the storage type of the two objects is identical. Definition at line 517 of file Variable.h. |
|
||||||||||||||
|
assignment operator specialization for possibly different parent quantity PQ1; if trying to instantiate, PQ and PQ1 should be different, since the case of PQ and PQ1 being the same type is handled by the assignment operator given above. Thus, SameType<>::sameType is always false and the IF construct tries to instantiate DimensionError<true> which is never defined. Consequently, this should never be instantiated correctly. Definition at line 486 of file Variable.h. |
|
||||||||||||||
|
assignment operator specialized version for some parent quantity PQ; used if PQ of the source and target quantity are identical; then we can be sure that the value of the source can be recalculated into the unit of the target. the form of Q1<> must satisfy the template parameter sequence for a Variable (or a other classes similarly derived fom Quantity); this prohibits assignment from general objects (strings etc.); comparison against self-assignment must be performed through void *, since &Q1 might be a pointer to a class different from that pointed to by this; thus, it is checked that the adresses of the two objects differ; the value of the source_quantity in the storage unit is extracted, converted into the unit of the present object, and the result is stored; only the variable_value is assigned, name and symbol of the present variable are not touched. It is assumed that the storage type of the two objects is identical. Definition at line 463 of file Variable.h. |
|
||||||||||
|
assignment operator assignment from same type; comparison against self assignment can be done by direct comparison of pointers; no need to convert values, since unit must be the same; raw value of new_variable is used, since no conversion into default unit is desired; only the variable value is assigned, name and symbol are not touched. Definition at line 436 of file Variable.h. |
|
||||||||||||||
|
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 1069 of file Variable.h. |
|
||||||||||||||
|
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 1056 of file Variable.h. |
|
||||||||||
|
equality compares identical types; use value to retrieve the variable value of the right hand side Variable and directly compare to variable_value. Definition at line 1046 of file Variable.h. |
|
||||||||||||||
|
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 1143 of file Variable.h. |
|
||||||||||||||
|
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 1130 of file Variable.h. |
|
||||||||||
|
comparison: greater than compares identical types; use value to retrieve the variabler value of the right hand side Variable and directly compare to variable_value. Definition at line 1120 of file Variable.h. |
|
||||||||||||||
|
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 1217 of file Variable.h. |
|
||||||||||||||
|
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 1204 of file Variable.h. |
|
||||||||||
|
comparison: greater equal compares identical types; use value to retrieve the variabler value of the right hand side Variable and directly compare to variable_value. Definition at line 1194 of file Variable.h. |
|
||||||||||
|
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 1384 of file Variable.h. |
|
||||||||||
|
store the value and unit of the variable in a std::string converts to a string by template Conversion Definition at line 1376 of file Variable.h. |
|
||||||||||||||
|
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 1339 of file Variable.h. References quantity::exp(). |
|
||||||||||||||
|
the alternative pow function with rational exponent returns a transient variable with the dimension 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 1314 of file Variable.h. |
|
||||||||||
|
print the value and the unit of the variable places these items on the ostream os and returns the reference to the os object, thus allowing chaining of operator<< calls. Definition at line 1370 of file Variable.h. |
|
||||||||||
|
read variable value and unit from a string central function for all input functions. |
|
||||||||||
|
the alternative sqrt function use as v.sqrt (), with v being an instantiation of a Variable Definition at line 1359 of file Variable.h. |
|
||||||||||
|
return the value in the standard unit; The stored variable_value is standardized using the Standardize () function for unit SU Definition at line 565 of file Variable.h. |
|
||||||||||
|
return the storage unit name; the name is interrogated from SU; static access. Definition at line 658 of file Variable.h. |
|
||||||||||
|
return the storage unit name; the name is interrogated from SU; dynamic access. Definition at line 653 of file Variable.h. |
|
||||||||||
|
return the storage unit symbol; the symbol is interrogated from SU; static access. Definition at line 648 of file Variable.h. |
|
||||||||||
|
return the storage unit symbol; the symbol is interrogated from SU; dynamic access. Definition at line 642 of file Variable.h. |
|
||||||||||
|
return the value in a unit with symbol string symbolstring; The string is checked at run time, this allows dynamic access. Consequently, when supplying an incorrect string for the symbol, this can not be detected at compile time, but only at run time. The stored variable_value is first standardized using the Standardize () function for unit SU, and then 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 617 of file Variable.h. |
|
||||||||||||||
|
return the value in a Composed unit; The stored variable_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 601 of file Variable.h. |
|
||||||||||||||
|
return the value in a Prefixed unit; The stored variable_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 588 of file Variable.h. |
|
||||||||||||||
|
return the value in a NonPrefixable unit NonPrefixable<BT, NU>; The stored variable_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 575 of file Variable.h. |
|
||||||||||
|
return the value in the storage unit; The stored variable_value is returned without recalculation. Definition at line 559 of file Variable.h. |
|
||||||||||
|
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 Variable to the canonical values. Definition at line 401 of file Variable.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(). |
|
||||||||||||||
|
copy constructor from some other quantity Q1 function not defined here, since in general, this copy constructor does not make sense! Only works if a specialized version is provided by a particular Variable<>; if this is not the case, missing reference should be reported by the linker; handles cases where PQ and PQ1 correspond to totally different quantities, but also where the storage type is different. |
|
||||||||||||||
|
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 Variable, provided the dimensions of the two objects are equal. This is tested with CheckSecondDimension. It is assumed that the storage type of the two objects is identical. Definition at line 369 of file Variable.h. |
|
||||||||||||||
|
copy constructor from quantity with different unit (conversion) specialized version for same parent quantity PQ; used if PQ of the target Variable 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 Variable; 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 Variable or other classes similarly derived fom Quantity; this prohibits the conversion from general objects (string etc.). It is assumed that the storage type of the two objects is identical. Definition at line 351 of file Variable.h. |
|
||||||||||||||
|
copy constructor initialize the parent quantity PQ; then copy the value, the name and symbol string of variable Definition at line 331 of file Variable.h. |
|
||||||||||||||||
|
constructor from different unit given by string constant takes a const char * 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 316 of file Variable.h. |
|
||||||||||||||||
|
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 and returned as a pointer to the base unit type BT; the unit object pointed to is later destroyed; the value is first dynamically standardized on the base of the unit determined, and then recalculated into the storage unit SU; first initializes base class; findBySymbol may throw a UnitMismatch exception. Definition at line 298 of file Variable.h. |
|
||||||||||||||||||||
|
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 283 of file Variable.h. |
|
||||||||||||||||
|
constructor from same unit takes an instance of the storage unit as the second argument and uses value directly. Definition at line 271 of file Variable.h. |
|
||||||||||
|
constructor Set the value to new_value and assume this to be in unit SU. Definition at line 265 of file Variable.h. |
|
||||||||||
|
default constructor Set the value to 0 (or equivalent) and assume this to be in unit SU. Definition at line 260 of file Variable.h. |
|
||||||||||||||||||||
|
operator* for left hand multiplication by ST generates new object to be returned; due to promotion and conversions, this may also work for factors with a type different from ST, as long as it can be matched; out of class declaration without friend does not work with factor type different from storage type, since in that case first the template argument ST is deducted from the first function argument, and 'this deduction does not consider ... conversions' (Vandevoorde/Josuttis, p. 489); second argument can be quantity object of any mode. Definition at line 1038 of file Variable.h. |
|
||||||||||||||||||||
|
binary operator+ handles the case of addition of a Dynamic object on the left hand side of the operator; this is converted into a Variable object of the right hand side type, which is only successful, if the Dynamic object is commensurate; finally addition is forwarded to the `generic' addition operator above; must be friend of the Variable class, since the first argument is not a Variable. Definition at line 923 of file Variable.h. |
|
||||||||||||||||||||
|
binary operator- handles the case of addition of a Dynamic object on the left hand side of the operator; this is converted into a Variable object of the right hand side type, which is only successful, if the Dynamic object is commensurate; finally addition is forwarded to the `generic' addition operator above; must be friend of the Variable class, since the first argument is not a Variable. Definition at line 1003 of file Variable.h. |
|
||||||||||||||||
|
division of a number by a variable the type of the result is generated through GenerateVariable by negating the dimension of the variable; Definition at line 1297 of file Variable.h. |
|
||||||||||||||||
|
read from a std::istream to the left of operator>> must be a friend to have std::istream & as the type of the first object; uses read from istream to the right of operator<<. Definition at line 1419 of file Variable.h. |
|
||||||||||||||||
|
read from string to the left of operator>> must be a friend to have std::string as the type of the first object Definition at line 1396 of file Variable.h. |
|
||||||||||
|
the sqrt function use as sqrt (v), with v being an instantiation of a Variable Definition at line 1347 of file Variable.h. |
|
|||||
|
the alternative pow function with static integer exponent returns a transient variable with the dimension 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 1328 of file Variable.h. |
|
|||||
|
the value of the Variable in the storage unit this data member is private, and can only be accessed through the member functions value (). Definition at line 253 of file Variable.h. |
1.3.6