STK::Arithmetic< TYPE > Struct Template Reference

Arithmetic properties of STK fundamental types. More...

#include <STK_Arithmetic.h>

Inheritance diagram for STK::Arithmetic< TYPE >:

List of all members.

Static Public Member Functions
static TYPE	NA () throw ()
	Adding a Non Avalaible (NA) special number.
static bool	isNA (TYPE const &x) throw ()
	Test if x is a Non Avalaible (NA) special number.
static bool	isInfinite (TYPE const &x) throw ()
	x is infinite.
static bool	isFinite (TYPE const &x) throw ()
	Test if x is finite : i.e.
Static Public Attributes
static const bool	hasNA = false
	True if the type has a representation for a "Not Available.".

---

Detailed Description

template<class TYPE>
struct STK::Arithmetic< TYPE >

Arithmetic properties of STK fundamental types.

This class allows a program to obtain information about the representation of a STK fundamental type on a given platform. For non-fundamental STK types, the functions will return 0 and the data members will all be false.

1. A NA (Not Available) type is defined. If the fundamental type have a quiet_NaN, a NA is a quiet_NaN and the quiet_NaN is no more available.
2. If the fundamental type does not have a NaN, the greatest value is used.
3. If the fundamental type is an Integral type (union), a NA is the value (if any) defined in the declaration.

The class arithmetic<TYPE> inherit from std::numeric_limits<TYPE> whom which we give hereafter the definition.

    template<typename _Tp>
    struct numeric_limits
    {
      // This will be true for all fundamental types (which have
      // specializations), and false for everything else.
      static const bool is_specialized = false;

      // The number of @c radix digits that be represented without change:  for
      // integer types, the number of non-sign bits in the mantissa; for
      // floating types, the number of @c radix digits in the mantissa.
      static const int digits = 0;

      // The number of base 10 digits that can be represented without change.
      static const int digits10 = 0;

      // True if the type is signed.
      static const bool is_signed = false;

      // True if the type is integer.
      static const bool is_integer = false;

      // True if the type uses an exact representation.  "All integer types are
      //  exact, but not all exact types are integer.  For example, rational and
      //  fixed-exponent representations are exact but not integer."
      //  [18.2.1.2]/15
      static const bool is_exact = false;

      // For integer types, specifies the base of the representation.  For
      // floating types, specifies the base of the exponent representation.
      static const int radix = 0;

      // The minimum negative integer such that @c radix raised to the power of
      // (one less than that integer) is a normalized floating point number.
      static const int min_exponent = 0;

      // The minimum negative integer such that 10 raised to that power is in
      // the range of normalized floating point numbers.
      static const int min_exponent10 = 0;

      // The maximum positive integer such that @c radix raised to the power of
      // (one less than that integer) is a representable finite floating point
      // number.
      static const int max_exponent = 0;

      // The maximum positive integer such that 10 raised to that power is in
      //    the range of representable finite floating point numbers.
      static const int max_exponent10 = 0;

      // True if the type has a representation for positive infinity.
      static const bool has_infinity = false;

      // True if the type has a representation for a quiet (non-signaling)
      // "Not a Number."
      static const bool has_quiet_NaN = false;

      // True if the type has a representation for a signaling
      //    "Not a Number."
      static const bool has_signaling_NaN = false;

      // See std::float_denorm_style for more information.
      static const float_denorm_style has_denorm = denorm_absent;

      // "True if loss of accuracy is detected as a denormalization loss,
      //    rather than as an inexact result." [18.2.1.2]/42
      static const bool has_denorm_loss = false;

      // True if-and-only-if the type adheres to the IEC 559 standard, also
      // known as IEEE 754.  (Only makes sense for floating point types.)
      static const bool is_iec559 = false;

      // "True if the set of values representable by the type is finite. All
      // built-in types are bounded, this member would be false for arbitrary
      // precision types." [18.2.1.2]/54
      static const bool is_bounded = false;

      // True if the type is @e modulo, that is, if it is possible to add two
      // positive numbers and have a result that wraps around to a third number
      // that is less.  Typically false for floating types, true for unsigned
      // integers, and true for signed integers.
      static const bool is_modulo = false;

      // True if trapping is implemented for this type.
      static const bool traps = false;

      static const bool tinyness_before = false;

      // See std::float_round_style for more information.  This is only
      // meaningful for floating types; integer types will all be
      // round_toward_zero.
      static const float_round_style round_style = round_toward_zero;

      // The minimum finite value, or for floating types with
      // denormalization, the minimum positive normalized value.
      static _Tp min() throw() { return static_cast<_Tp>(0); }

      // The maximum finite value.
      static _Tp max() throw() { return static_cast<_Tp>(0); }

      // The @e machine @e epsilon:  the difference between 1 and the least
      //value greater than 1 that is representable.
      static _Tp epsilon() throw() { return static_cast<_Tp>(0); }

      // The maximum rounding error measurement (see LIA-1).
      static _Tp round_error() throw() { return static_cast<_Tp>(0); }

      // The representation of positive infinity, if @c has_infinity.
      static _Tp infinity() throw()  { return static_cast<_Tp>(0); }

      // The representation of a quiet "Not a Number," if @c has_quiet_NaN.
      static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); }

      // The representation of a signaling "Not a Number," if
      // @c has_signaling_NaN.
      static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); }

      // The minimum positive denormalized value.  For types where
      // @c has_denorm is false, this is the minimum positive normalized
      //  value.
      static _Tp denorm_min() throw() { return static_cast<_Tp>(0); }
  };

Definition at line 198 of file STK_Arithmetic.h.

---

Member Function Documentation

template<class TYPE >

static TYPE STK::Arithmetic< TYPE >::NA

(

)

throw () [inline, static]

Adding a Non Avalaible (NA) special number.

Returns:

the NA value of the type TYPE

Definition at line 203 of file STK_Arithmetic.h.

Referenced by STK::Arithmetic< String >::isNA(), and STK::operator>>().

{ return static_cast<TYPE>(0);}

template<class TYPE >

static bool STK::Arithmetic< TYPE >::isNA

(

TYPE const &

x

)

throw () [inline, static]

Test if x is a Non Avalaible (NA) special number.

Parameters:

x	the value to test.

Returns:

true if the parameter x is a NA value, false otherwise

Definition at line 212 of file STK_Arithmetic.h.

Referenced by STK::Arithmetic< String >::isFinite(), STK::Arithmetic< Sign >::isFinite(), STK::Arithmetic< Real >::isFinite(), STK::Arithmetic< Integer >::isFinite(), STK::Arithmetic< Binary >::isFinite(), and STK::Arithmetic< TYPE >::isFinite().

  { return false;}

template<class TYPE >

static bool STK::Arithmetic< TYPE >::isInfinite

(

TYPE const &

x

)

throw () [inline, static]

x is infinite.

Parameters:

x	the value to test.

Returns:

true if the parameter x is an infinite value, false otherwise

Definition at line 220 of file STK_Arithmetic.h.

Referenced by STK::Arithmetic< Sign >::isFinite(), STK::Arithmetic< Real >::isFinite(), STK::Arithmetic< Binary >::isFinite(), and STK::Arithmetic< TYPE >::isFinite().

 { return false; }

template<class TYPE >

static bool STK::Arithmetic< TYPE >::isFinite

(

TYPE const &

x

)

throw () [inline, static]

Test if x is finite : i.e.

if x is not infinite and x is not a NA value.

Parameters:

x	the value to test.

Returns:

true if the parameter x is a finite value, false otherwise

Definition at line 229 of file STK_Arithmetic.h.

References STK::Arithmetic< TYPE >::isInfinite(), and STK::Arithmetic< TYPE >::isNA().

  { return (!isNA(x) && !isInfinite(x));}

---

Member Data Documentation

template<class TYPE >

const bool STK::Arithmetic< TYPE >::hasNA = false [static]

True if the type has a representation for a "Not Available.".

Definition at line 206 of file STK_Arithmetic.h.

---

The documentation for this struct was generated from the following file:

• STK_Arithmetic.h