00001 ////////////////////////////////////////////////////////////////////////
00002 // How to use this file: //
00003 // ===================== //
00004 // #define NUMBER Double /* The name of the class */ //
00005 // #define TYPE double /* The storage data type */ //
00006 // #define ZERO 0.0 /* The value zero in that data type */ //
00007 // //
00008 // class Double { //
00009 // // ... //
00010 // #include <j2k/Fred/Math/Number/NbVerify.hpp> //
00011 // #include <j2k/Fred/Math/Number/NbOperator1.hpp> //
00012 // //
00013 // /* Operator right handside */ //
00014 // /* Might consider automatic type upgrading for simplicity... //
00015 // #define TYPE2 double //
00016 // #include <j2k/Fred/Math/Number/NbOperator2.hpp> //
00017 // //
00018 // #define TYPE2 float //
00019 // #include <j2k/Fred/Math/Number/NbOperator2.hpp> //
00020 // //
00021 // #define TYPE2 signed long //
00022 // #include <j2k/Fred/Math/Number/NbOperator2.hpp> //
00023 // #define TYPE2 unsigned long //
00024 // #include <j2k/Fred/Math/Number/NbOperator2.hpp> //
00025 // //
00026 // #define TYPE2 signed short //
00027 // #include <j2k/Fred/Math/Number/NbOperator2.hpp> //
00028 // #define TYPE2 unsigned short //
00029 // #include <j2k/Fred/Math/Number/NbOperator2.hpp> //
00030 // //
00031 // #define TYPE2 signed char //
00032 // #include <j2k/Fred/Math/Number/NbOperator2.hpp> //
00033 // #define TYPE2 unsigned char //
00034 // #include <j2k/Fred/Math/Number/NbOperator2.hpp> //
00035 // //
00036 // #define TYPE2 signed int //
00037 // #include <j2k/Fred/Math/Number/NbOperator2.hpp> //
00038 // #define TYPE2 unsigned int //
00039 // #include <j2k/Fred/Math/Number/NbOperator2.hpp> //
00040 // }; //
00041 // #undef TYPE //
00042 // #undef ZERO //
00043 // #undef NUMBER //
00044 ////////////////////////////////////////////////////////////////////////
00045
00046 // Missing += *= -= /= <<= >>= &&= &= |= etc.
00047
00048 // Too long to do it by hand, so let's do it with a Macro ! =)
00049 // MC_NUMBER_Operators2( Double, double, double )
00050 // MC_NUMBER_Operators2( Double, double, int )
00051 // MC_NUMBER_Operators2( Double, double, float )
00052 // MC_NUMBER_Operators2( Double, double, long )
00053
00054 #ifndef NUMBER
00055 #error "NUMBER is not defined !"
00056 #endif
00057
00058 #ifndef TYPE
00059 #error "TYPE is not defined !"
00060 #endif
00061
00062 #ifndef TYPE2
00063 #error "TYPE is not defined !"
00064 #endif
00065
00066
00067 // Compare Operators: Part 3
00068 friend BOOL isEqualTo( const NUMBER& l, TYPE2 n ) {
00069 TYPE v = (TYPE)n;
00070 int temp = MathStateEqualTo[ (int)l.state ][ (int)verify(v) ];
00071 if ( temp < 2 ) return (BOOL)temp;
00072 return ( l.value == v );
00073 }
00074
00075 friend BOOL isLessThan( const NUMBER& l, TYPE2 n ) {
00076 TYPE v = (TYPE)n;
00077 int temp = MathStateLessThan[ (int)l.state ][ (int)verify(v) ];
00078 if ( temp < 2 ) return (BOOL)temp;
00079 return ( l.value < v );
00080 }
00081
00082 friend BOOL isBiggerThan( const NUMBER& l, TYPE2 n ) {
00083 TYPE v = (TYPE)n;
00084 int temp = MathStateBiggerThan[ (int)l.state ][ (int)verify(v) ];
00085 if ( temp < 2 ) return (BOOL)temp;
00086 return (l.value > v );
00087 }
00088
00089 inline friend BOOL operator==( const NUMBER& l, TYPE2 n ) {
00090 return isEqualTo( l, n );
00091 }
00092
00093 inline friend BOOL operator!=( const NUMBER& l, TYPE2 n ) {
00094 return !isEqualTo( l, n );
00095 }
00096
00097 inline friend BOOL operator<( const NUMBER& l, TYPE2 n ) {
00098 return isLessThan( l, n );
00099 }
00100
00101 inline friend BOOL operator<=( const NUMBER& l, TYPE2 n ) {
00102 return ( isLessThan( l, n ) || isEqualTo( l, n ) );
00103 }
00104
00105 inline friend BOOL operator>( const NUMBER& l, TYPE2 n ) {
00106 return isBiggerThan( l, n );
00107 }
00108
00109 inline friend BOOL operator>=( const NUMBER& l, TYPE2 n ) {
00110 return ( isBiggerThan( l, n ) || isEqualTo( l, n ) );
00111 }
00112
00113 inline friend BOOL operator==( TYPE2 n, const NUMBER& r ) {
00114 return isEqualTo( r, n );
00115 }
00116
00117 inline friend BOOL operator!=( TYPE2 n, const NUMBER& r ) {
00118 return !isEqualTo( r, n );
00119 }
00120
00121 inline friend BOOL operator<( TYPE2 n, const NUMBER& r ) {
00122 return isBiggerThan( r, n );
00123 }
00124
00125 inline friend BOOL operator<=( TYPE2 n, const NUMBER& r ) {
00126 return ( isBiggerThan( r, n ) || isEqualTo( r, n ) );
00127 }
00128
00129 inline friend BOOL operator>( TYPE2 n, const NUMBER& r ) {
00130 return isLessThan( r, n );
00131 }
00132
00133 inline friend BOOL operator>=( TYPE2 n, const NUMBER& r ) {
00134 return ( isLessThan( r, n ) || isEqualTo( r, n ) );
00135 }
00136
00137 // Arithmetic Operators: Part 2
00138 friend NUMBER add( const NUMBER& l, TYPE2 n ) {
00139 TYPE v = (TYPE)n;
00140 MathState s = MathStateAdd[ (int)l.state ][ (int)verify(v) ];
00141 return NUMBER( l.value + v, s );
00142 }
00143
00144 friend NUMBER sub( const NUMBER& l, TYPE2 n ) {
00145 TYPE v = (TYPE)n;
00146 MathState s = MathStateSub[ (int)l.state ][ (int)verify(v) ];
00147 return NUMBER( l.value - v, s );
00148 }
00149
00150 friend NUMBER sub( TYPE2 n, const NUMBER& r ) {
00151 TYPE v = (TYPE)n;
00152 MathState s = MathStateSub[ (int)verify(v) ][ (int)r.state ];
00153 return NUMBER( v - r.value, s );
00154 }
00155
00156 friend NUMBER mult( const NUMBER& l, TYPE2 n ) {
00157 TYPE v = (TYPE)n;
00158 MathState s = MathStateMult[ (int)l.state ][ (int)verify(v) ];
00159 return NUMBER( l.value * v, s );
00160 }
00161
00162 friend NUMBER div( const NUMBER& l, TYPE2 n ) {
00163 TYPE v = (TYPE)n;
00164 MathState s = MathStateDiv[ (int)l.state ][ (int)verify(v) ];
00165 if ( s != Valid ) return NUMBER( l.value, s );
00166 return NUMBER( l.value / v, s );
00167 }
00168
00169 friend NUMBER div( TYPE2 n, const NUMBER& r ) {
00170 TYPE v = (TYPE)n;
00171 MathState s = MathStateDiv[ (int)verify(v) ][ (int)r.state ];
00172 if ( s != Valid ) return NUMBER( v, s );
00173 return NUMBER( v / r.value, s );
00174 }
00175
00176 inline friend NUMBER operator+( TYPE2 n, const NUMBER& r ) {
00177 return add( r, n );
00178 }
00179
00180 inline friend NUMBER operator-( TYPE2 n, const NUMBER& r ) {
00181 return sub( n, r );
00182 }
00183
00184 inline friend NUMBER operator*( TYPE2 n, const NUMBER& r ) {
00185 return mult( r, n );
00186 }
00187
00188 inline friend NUMBER operator/( TYPE2 n, const NUMBER& r ) {
00189 return div( n, r );
00190 }
00191
00192 // Arithmetic Operators: Part 3
00193 inline friend NUMBER operator+( const NUMBER& l, TYPE2 n ) {
00194 return add( l, n );
00195 }
00196
00197 inline friend NUMBER operator-( const NUMBER& l, TYPE2 n ) {
00198 return sub( l, n );
00199 }
00200
00201 inline friend NUMBER operator*( const NUMBER& l, TYPE2 n ) {
00202 return mult( l, n );
00203 }
00204
00205 inline friend NUMBER operator/( const NUMBER& l, TYPE2 n ) {
00206 return div( l, n );
00207 }
00208
00209 // Other Operators: Part 2
00210 inline const NUMBER& operator=(TYPE2 n) {
00211 value = (TYPE)n;
00212 state = verify( value );
00213 return *this;
00214 }
00215
00216 inline operator TYPE2() const { return (TYPE2)value; }
00217
00218
00219 // We don't need it anymore...
00220 #undef TYPE2
1.2.11.1 written by Dimitri van Heesch,
© 1997-2001