Homepage Demos Overview Downloads Tutorials Reference
Credits

precisio.h

Go to the documentation of this file.
00001 //$$ precisio.h                          floating point constants
00002 
00003 #ifndef PRECISION_LIB
00004 #define PRECISION_LIB 0
00005 
00006 #ifdef _STANDARD_                 // standard library available
00007 #include <limits>
00008 #endif
00009 
00010 #ifdef use_namespace
00011 namespace NEWMAT {
00012 #endif
00013 
00014 #ifdef _STANDARD_                 // standard library available
00015 
00016 using namespace std;
00017   
00018 class FloatingPointPrecision
00019 {
00020 public:
00021    static int Dig()              // number of decimal digits or precision
00022       { return numeric_limits<Real>::digits10 ; }
00023 
00024    static Real Epsilon()         // smallest number such that 1+Eps!=Eps
00025       { return numeric_limits<Real>::epsilon(); }
00026 
00027    static int Mantissa()         // bits in mantisa
00028       { return numeric_limits<Real>::digits; }
00029 
00030    static Real Maximum()         // maximum value
00031       { return numeric_limits<Real>::max(); }
00032 
00033    static int MaximumDecimalExponent()  // maximum decimal exponent
00034       { return numeric_limits<Real>::max_exponent10; }
00035 
00036    static int MaximumExponent()  // maximum binary exponent
00037       { return numeric_limits<Real>::max_exponent; }
00038 
00039    static Real LnMaximum()       // natural log of maximum
00040       { return (Real)log(Maximum()); }
00041 
00042    static Real Minimum()         // minimum positive value
00043       { return numeric_limits<Real>::min(); } 
00044 
00045    static int MinimumDecimalExponent() // minimum decimal exponent
00046       { return numeric_limits<Real>::min_exponent10; }
00047 
00048    static int MinimumExponent()  // minimum binary exponent
00049       { return numeric_limits<Real>::min_exponent; }
00050 
00051    static Real LnMinimum()       // natural log of minimum
00052       { return (Real)log(Minimum()); }
00053 
00054    static int Radix()            // exponent radix
00055       { return numeric_limits<Real>::radix; }
00056 
00057    static int Rounds()           // addition rounding (1 = does round)
00058    {
00059     return numeric_limits<Real>::round_style ==
00060      round_to_nearest ? 1 : 0;
00061    }
00062 
00063 };
00064 
00065 
00066 #else                              // _STANDARD_ not defined
00067 
00068 #ifndef SystemV                    // if there is float.h
00069 
00070 
00071 #ifdef USING_FLOAT
00072 
00073 
00074 class FloatingPointPrecision
00075 {
00076 public:
00077    static int Dig()
00078       { return FLT_DIG; }        // number of decimal digits or precision
00079 
00080    static Real Epsilon()
00081       { return FLT_EPSILON; }    // smallest number such that 1+Eps!=Eps
00082 
00083    static int Mantissa()
00084       { return FLT_MANT_DIG; }   // bits in mantisa
00085 
00086    static Real Maximum()
00087       { return FLT_MAX; }        // maximum value
00088 
00089    static int MaximumDecimalExponent()
00090       { return FLT_MAX_10_EXP; } // maximum decimal exponent
00091 
00092    static int MaximumExponent()
00093       { return FLT_MAX_EXP; }    // maximum binary exponent
00094 
00095    static Real LnMaximum()
00096       { return (Real)log(Maximum()); } // natural log of maximum
00097 
00098    static Real Minimum()
00099       { return FLT_MIN; }        // minimum positive value
00100 
00101    static int MinimumDecimalExponent()
00102       { return FLT_MIN_10_EXP; } // minimum decimal exponent
00103 
00104    static int MinimumExponent()
00105       { return FLT_MIN_EXP; }    // minimum binary exponent
00106 
00107    static Real LnMinimum()
00108       { return (Real)log(Minimum()); } // natural log of minimum
00109 
00110    static int Radix()
00111       { return FLT_RADIX; }      // exponent radix
00112 
00113    static int Rounds()
00114       { return FLT_ROUNDS; }     // addition rounding (1 = does round)
00115 
00116 };
00117 
00118 #endif                           // USING_FLOAT
00119 
00120 
00121 #ifdef USING_DOUBLE
00122 
00123 class FloatingPointPrecision
00124 {
00125 public:
00126 
00127    static int Dig()
00128       { return DBL_DIG; }        // number of decimal digits or precision
00129 
00130    static Real Epsilon()
00131       { return DBL_EPSILON; }    // smallest number such that 1+Eps!=Eps
00132 
00133    static int Mantissa()
00134       { return DBL_MANT_DIG; }   // bits in mantisa
00135 
00136    static Real Maximum()
00137       { return DBL_MAX; }        // maximum value
00138 
00139    static int MaximumDecimalExponent()
00140       { return DBL_MAX_10_EXP; } // maximum decimal exponent
00141 
00142    static int MaximumExponent()
00143       { return DBL_MAX_EXP; }    // maximum binary exponent
00144 
00145    static Real LnMaximum()
00146       { return (Real)log(Maximum()); } // natural log of maximum
00147 
00148    static Real Minimum()
00149    {
00150 //#ifdef __BCPLUSPLUS__
00151 //       return 2.225074e-308;     // minimum positive value
00152 //#else
00153        return DBL_MIN;
00154 //#endif
00155    }
00156 
00157    static int MinimumDecimalExponent()
00158       { return DBL_MIN_10_EXP; } // minimum decimal exponent
00159 
00160    static int MinimumExponent()
00161       { return DBL_MIN_EXP; }    // minimum binary exponent
00162 
00163    static Real LnMinimum()
00164       { return (Real)log(Minimum()); } // natural log of minimum
00165 
00166 
00167    static int Radix()
00168       { return FLT_RADIX; }      // exponent radix
00169 
00170    static int Rounds()
00171       { return FLT_ROUNDS; }     // addition rounding (1 = does round)
00172 
00173 };
00174 
00175 #endif                             // USING_DOUBLE
00176 
00177 #else                              // if there is no float.h
00178 
00179 #ifdef USING_FLOAT
00180 
00181 class FloatingPointPrecision
00182 {
00183 public:
00184 
00185    static Real Epsilon()
00186       { return pow(2.0,(int)(1-FSIGNIF)); }
00187                                    // smallest number such that 1+Eps!=Eps
00188 
00189    static Real Maximum()
00190       { return MAXFLOAT; }            // maximum value
00191 
00192    static Real LnMaximum()
00193       { return (Real)log(Maximum()); }  // natural log of maximum
00194 
00195    static Real Minimum()
00196       { return MINFLOAT; }             // minimum positive value
00197 
00198    static Real LnMinimum()
00199       { return (Real)log(Minimum()); }  // natural log of minimum
00200 
00201 };
00202 
00203 #endif                                  // USING_FLOAT
00204 
00205 
00206 #ifdef USING_DOUBLE
00207 
00208 class FloatingPointPrecision
00209 {
00210 public:
00211 
00212    static Real Epsilon()
00213       { return pow(2.0,(int)(1-DSIGNIF)); }
00214                                       // smallest number such that 1+Eps!=Eps
00215 
00216    static Real Maximum()
00217       { return MAXDOUBLE; }           // maximum value
00218 
00219    static Real LnMaximum()
00220       { return LN_MAXDOUBLE; }        // natural log of maximum
00221 
00222    static Real Minimum()
00223       { return MINDOUBLE; }
00224 
00225    static Real LnMinimum()
00226       { return LN_MINDOUBLE; }        // natural log of minimum
00227 };
00228 
00229 #endif                                // USING_DOUBLE
00230 
00231 #endif                                // SystemV
00232 
00233 #endif                                // _STANDARD_
00234 
00235 #ifdef use_namespace
00236 }
00237 #endif                                // use_namespace
00238 
00239 
00240 
00241 #endif                                // PRECISION_LIB

newmat11b
Generated Tue Aug 16 16:32:01 2005 by Doxygen 1.4.4