00001 #ifndef __J2K__Number_Macro_HPP__
00002 #define __J2K__Number_Macro_HPP__
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014 #define MC_Number_Verify( cast, ZERO )
00015 inline void verify() {
00016 if ( s != Valid ) return;
00017 if ( temp > ZERO ) { status = Pos; }
00018 if ( temp < ZERO ) { status = Neg; }
00019 status = Zero;
00020 }
00021
00022 inline MathState verify( cast n ) {
00023 if ( n > ZERO ) return Pos;
00024 if ( n < ZERO ) return Neg;
00025 return Zero;
00026 }
00027
00028 MathState getState( const char* s ) {
00029 if ( s == NULL ) return Zero;
00030 if ( strlen(s) < 2 ) return Valid;
00031
00032 char* sUp = strupr( strdup( s ) );
00033
00034 char* sPosInf = "POSITIVE INFINITE POSINFINITE +INFINITE";
00035 char* sNegInf = "NEGATIVE INFINITE NEGINFINITE -INFINITE";
00036 char* sNaN = "NAN";
00037 char* sFPError = "FPERROR FLOATING-POINT ERROR FLOAT ERROR";
00038
00039 char* f1 = strstr( sPosInf, sUp );
00040 char* f2 = strstr( sNegInf, sUp );
00041 char* f3 = strstr( sNaN, sUp );
00042 char* f4 = strstr( sFPError, sUp );
00043
00044 long n1 = (long)( f1 - sUp );
00045 long n2 = (long)( f2 - sUp );
00046 long n3 = (long)( f3 - sUp );
00047 long n4 = (long)( f4 - sUp );
00048
00049 #ifdef __J2K__DEBUG
00050 printf("Up=[%s](%d)\n", sUp, strlen(sUp) );
00051 printf("f1=[%s](%d)\n", f1, n1 );
00052 printf("f2=[%s](%d)\n", f2, n2 );
00053 printf("f3=[%s](%d)\n", f3, n3 );
00054 printf("f4=[%s](%d)\n", f4, n4 );
00055 #endif
00056
00057 if ( n1 > 0 ) return PosInf;
00058 if ( n2 > 0 ) return NegInf;
00059 if ( n3 > 0 ) return NaN;
00060 if ( n4 > 0 ) return FPError;
00061
00062 return Valid;
00063 }
00064
00065
00066 #define MC_Number_Operators1( Number, cast )
00067
00068 friend BOOL isEqualTo( const Number& l, const Number& r ) {
00069 int temp = MathStateEqualTo[ (int)l.state ][ (int)r.state ];
00070 if ( temp < 2 ) return (BOOL)temp;
00071 return ( l.value == r.value );
00072 }
00073
00074 friend BOOL isLessThan( const Number& l, const Number& r ) {
00075 int temp = MathStateLessThan[ (int)l.state ][ (int)r.state ];
00076 if ( temp < 2 ) return (BOOL)temp;
00077 return (l.value < r.value);
00078 }
00079
00080 friend BOOL isBiggerThan( const Number& l, const Number& r ) {
00081 int temp = MathStateBiggerThan[ (int)l.state ][ (int)r.state ];
00082 if ( temp < 2 ) return (BOOL)temp;
00083 return (l.value > r.value);
00084 }
00085
00086 inline friend BOOL operator==( const Number& l, const Number& r ) {
00087 return isEqualTo( l, r );
00088 }
00089
00090 inline friend BOOL operator!=( const Number& l, const Number& r ) {
00091 return !isEqualTo( l, r );
00092 }
00093
00094 inline friend BOOL operator<( const Number& l, const Number& r ) {
00095 return isLessThan( l, r );
00096 }
00097
00098 inline friend BOOL operator<=( const Number& l, const Number& r ) {
00099 return ( isLessThan( l, r ) || isEqualTo( l, r ) );
00100 }
00101
00102 inline friend BOOL operator>( const Number& l, const Number& r ) {
00103 return isBiggerThan( l, r );
00104 }
00105
00106 inline friend BOOL operator>=( const Number& l, const Number& r ) {
00107 return ( isBiggerThan( l, r ) || isEqualTo( l, r ) );
00108 }
00109
00110
00111 friend Number add( const Number& l, const Number& r ) {
00112 MathState s = MathStateAdd[ (int)l.state ][ (int)r.state ];
00113 return Number( l.value + r.value, s );
00114 }
00115
00116 friend Number sub( const Number& l, const Number& r ) {
00117 MathState s = MathStateSub[ (int)l.state ][ (int)r.state ];
00118 return Number( l.value - r.value, s );
00119 }
00120
00121 friend Number mult( const Number& l, const Number& r ) {
00122 MathState s = MathStateMult[ (int)l.state ][ (int)r.state ];
00123 return Number( l.value * r.value, s );
00124 }
00125
00126 friend Number div( const Number& l, const Number& r ) {
00127 MathState s = MathStateDiv[ (int)l.state ][ (int)r.state ];
00128 if ( s != Valid ) return Number( l.value, s );
00129 return Number( l.value / r.value, s );
00130 }
00131
00132 inline friend Number operator+( const Number& l, const Number& r ) {
00133 return add( l, r );
00134 }
00135
00136 inline friend Number operator-( const Number& l, const Number& r ) {
00137 return sub( l, r );
00138 }
00139
00140 inline friend Number operator*( const Number& l, const Number& r ) {
00141 return mult( l, r );
00142 }
00143
00144 inline friend Number operator/( const Number& l, const Number& r ) {
00145 return div( l, r );
00146 }
00147
00148
00149 inline const Number &operator=(const Number& N ) {
00150 value = N.value;
00151 status = N.status;
00152 return *this;
00153 }
00154
00155 inline Number operator!() {
00156 return Number( !value, status );
00157 }
00158
00159 inline Number operator-() {
00160 if ( (int)status < 4 ) return Number( (-1) * value, Valid );
00161 return Number( (-1) * value, status );
00162 }
00163
00164
00165 inline Number operator--() {
00166 --value;
00167 return *this;
00168 }
00169
00170 inline Number operator--( int ) {
00171 value--;
00172 return *this;
00173 }
00174
00175 inline Number operator++() {
00176 ++value;
00177 return *this;
00178 }
00179
00180 inline Number operator++( int ) {
00181 value++;
00182 return *this;
00183 }
00184
00185
00186 #define MC_Number_Operators2( Number, cast, number )
00187
00188 friend BOOL isEqualTo( const Number& l, const number& n ) {
00189 cast v = (cast)n;
00190 int temp = MathStateEqualTo[ (int)l.state ][ (int)verify(v) ];
00191 if ( temp < 2 ) return (BOOL)temp;
00192 return ( l.value == v );
00193 }
00194
00195 friend BOOL isLessThan( const Number& l, const number& n ) {
00196 cast v = (cast)n;
00197 int temp = MathStateLessThan[ (int)l.state ][ (int)verify(v) ];
00198 if ( temp < 2 ) return (BOOL)temp;
00199 return ( l.value < v );
00200 }
00201
00202 friend BOOL isBiggerThan( const Number& l, const number& n ) {
00203 cast v = (cast)n;
00204 int temp = MathStateBiggerThan[ (int)l.state ][ (int)verify(v) ];
00205 if ( temp < 2 ) return (BOOL)temp;
00206 return (l.value > v );
00207 }
00208
00209 inline friend BOOL operator==( const Number& l, const number n ) {
00210 return isEqualTo( l, n );
00211 }
00212
00213 inline friend BOOL operator!=( const Number& l, const number n ) {
00214 return !isEqualTo( l, n );
00215 }
00216
00217 inline friend BOOL operator<( const Number& l, const number n ) {
00218 return isLessThan( l, n );
00219 }
00220
00221 inline friend BOOL operator<=( const Number& l, const number n ) {
00222 return ( isLessThan( l, n ) || isEqualTo( l, n ) );
00223 }
00224
00225 inline friend BOOL operator>( const Number& l, const number n ) {
00226 return isBiggerThan( l, n );
00227 }
00228
00229 inline friend BOOL operator>=( const Number& l, const number n ) {
00230 return ( isBiggerThan( l, n ) || isEqualTo( l, n ) );
00231 }
00232
00233 inline friend BOOL operator==( const number n, const Number& r ) {
00234 return isEqualTo( r, n );
00235 }
00236
00237 inline friend BOOL operator!=( const number n, const Number& r ) {
00238 return !isEqualTo( r, n );
00239 }
00240
00241 inline friend BOOL operator<( const number n, const Number& r ) {
00242 return isBiggerThan( r, n );
00243 }
00244
00245 inline friend BOOL operator<=( const number n, const Number& r ) {
00246 return ( isBiggerThan( r, n ) || isEqualTo( r, n ) );
00247 }
00248
00249 inline friend BOOL operator>( const number n, const Number& r ) {
00250 return isLessThan( r, n );
00251 }
00252
00253 inline friend BOOL operator>=( const number n, const Number& r ) {
00254 return ( isLessThan( r, n ) || isEqualTo( r, n ) );
00255 }
00256
00257
00258 friend Number add( const Number& l, const number n ) {
00259 cast v = (cast)n;
00260 MathState s = MathStateAdd[ (int)l.state ][ (int)verify(v) ];
00261 return Number( l.value + v, s );
00262 }
00263
00264 friend Number sub( const Number& l, const number n ) {
00265 cast v = (cast)n;
00266 MathState s = MathStateSub[ (int)l.state ][ (int)verify(v) ];
00267 return Number( l.value - v, s );
00268 }
00269
00270 friend Number sub( const number n, const Number& r ) {
00271 cast v = (cast)n;
00272 MathState s = MathStateSub[ (int)verify(v) ][ (int)r.state ]
00273 return Number( v - r.value, s );
00274 }
00275
00276 friend Number mult( const Number& l, const number n ) {
00277 cast v = (cast)n;
00278 MathState s = MathStateMult[ (int)l.state ][ (int)verify(v) ];
00279 return Number( l.value * v, s );
00280 }
00281
00282 friend Number div( const Number& l, const number n ) {
00283 cast v = (cast)n;
00284 MathState s = MathStateDiv[ (int)l.state ][ (int)verify(v) ];
00285 if ( s != Valid ) return Number( l.value, s );
00286 return Number( l.value / v, s );
00287 }
00288
00289 friend Number div( const number n, const Number& r ) {
00290 cast v = (cast)n;
00291 MathState s = MathStateDiv[ (int)verify(v) ][ (int)r.state ];
00292 if ( s != Valid ) return Number( v, s );
00293 return Number( v / r.value, s );
00294 }
00295
00296 inline friend Number operator+( number n, const Number& r ) {
00297 return add( r, n );
00298 }
00299
00300 inline friend Number operator-( number n, const Number& r ) {
00301 return sub( n, r );
00302 }
00303
00304 inline friend Number operator*( number n, const Number& r ) {
00305 return mult( r, n );
00306 }
00307
00308 inline friend Number operator/( number n, const Number& r ) {
00309 return div( n, r );
00310 }
00311
00312
00313 inline friend Number operator+( const Number& l, const number n ) {
00314 return add( l, n );
00315 }
00316
00317 inline friend Number operator-( const Number& l, const number n ) {
00318 return sub( l, n );
00319 }
00320
00321 inline friend Number operator*( const Number& l, const number n ) {
00322 return mult( l, n );
00323 }
00324
00325 inline friend Number operator/( const Number& l, const number n ) {
00326 return div( l, n );
00327 }
00328
00329
00330 inline const Number &operator=(number n) {
00331 value = (cast)n;
00332 status = verify( value );
00333 return *this;
00334 }
00335
00336 inline operator number() const { return (number)value; }
00337
00338
00339
00340 #endif
