Main Page   Packages   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Search  

C:/temp/src/j2k/Beta/Math/Number/NbOperator2.hpp File Reference

Go to the source code of this file.

Functions

BOOL isEqualTo (const NUMBER &l, TYPE2 n)
BOOL isLessThan (const NUMBER &l, TYPE2 n)
BOOL isBiggerThan (const NUMBER &l, TYPE2 n)
BOOL operator== (const NUMBER &l, TYPE2 n)
BOOL operator!= (const NUMBER &l, TYPE2 n)
BOOL operator< (const NUMBER &l, TYPE2 n)
BOOL operator<= (const NUMBER &l, TYPE2 n)
BOOL operator> (const NUMBER &l, TYPE2 n)
BOOL operator>= (const NUMBER &l, TYPE2 n)
BOOL operator== (TYPE2 n, const NUMBER &r)
BOOL operator!= (TYPE2 n, const NUMBER &r)
BOOL operator< (TYPE2 n, const NUMBER &r)
BOOL operator<= (TYPE2 n, const NUMBER &r)
BOOL operator> (TYPE2 n, const NUMBER &r)
BOOL operator>= (TYPE2 n, const NUMBER &r)
NUMBER add (const NUMBER &l, TYPE2 n)
NUMBER sub (const NUMBER &l, TYPE2 n)
NUMBER sub (TYPE2 n, const NUMBER &r)
NUMBER mult (const NUMBER &l, TYPE2 n)
NUMBER div (const NUMBER &l, TYPE2 n)
NUMBER div (TYPE2 n, const NUMBER &r)
NUMBER operator+ (TYPE2 n, const NUMBER &r)
NUMBER operator- (TYPE2 n, const NUMBER &r)
NUMBER operator * (TYPE2 n, const NUMBER &r)
NUMBER operator/ (TYPE2 n, const NUMBER &r)
NUMBER operator+ (const NUMBER &l, TYPE2 n)
NUMBER operator- (const NUMBER &l, TYPE2 n)
NUMBER operator * (const NUMBER &l, TYPE2 n)
NUMBER operator/ (const NUMBER &l, TYPE2 n)
const NUMBER & operator= (TYPE2 n)
 operator TYPE2 () const

Function Documentation

friend NUMBER add (  const NUMBER &    l,
TYPE2    n
) 
 

Definition at line 138 of file NbOperator2.hpp.

Referenced by JCounter::operator+(), operator+(), and DBase::string(). 

00138                                                 {              
00139     TYPE v = (TYPE)n;                                                 
00140     MathState s = MathStateAdd[ (int)l.state ][ (int)verify(v) ];     
00141     return NUMBER( l.value + v, s );                                  
00142   }

friend NUMBER div (  TYPE2    n,
const NUMBER &    r
) 
 

Definition at line 169 of file NbOperator2.hpp.

Referenced by operator/(). 

00169                                                 {              
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   }

friend NUMBER div (  const NUMBER &    l,
TYPE2    n
) 
 

Definition at line 162 of file NbOperator2.hpp.

00162                                                 {              
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   }

friend BOOL isBiggerThan (  const NUMBER &    l,
TYPE2    n
) 
 

Definition at line 82 of file NbOperator2.hpp.

Referenced by operator<(), operator<=(), operator>(), and operator>=(). 

00082                                                        {      
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   }

friend BOOL isEqualTo (  const NUMBER &    l,
TYPE2    n
) 
 

Definition at line 68 of file NbOperator2.hpp.

Referenced by operator!=(), operator<=(), operator==(), and operator>=(). 

00068                                                     {         
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   }

friend BOOL isLessThan (  const NUMBER &    l,
TYPE2    n
) 
 

Definition at line 75 of file NbOperator2.hpp.

Referenced by operator<(), operator<=(), operator>(), and operator>=(). 

00075                                                      {        
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   }

friend NUMBER mult (  const NUMBER &    l,
TYPE2    n
) 
 

Definition at line 156 of file NbOperator2.hpp.

Referenced by operator *(), jMatrixStack::rotxdeg(), jMatrixStack::rotxrad(), jMatrixStack::rotydeg(), jMatrixStack::rotyrad(), jMatrixStack::rotzdeg(), jMatrixStack::rotzrad(), jMatrixStack::scale(), and jMatrixStack::trans(). 

00156                                                  {             
00157     TYPE v = (TYPE)n;                                                 
00158     MathState s = MathStateMult[ (int)l.state ][ (int)verify(v) ];    
00159     return NUMBER( l.value * v, s );                                  
00160   }

friend NUMBER operator * (  const NUMBER &    l,
TYPE2    n
)  [inline]
 

Definition at line 201 of file NbOperator2.hpp.

00201                                                              { 
00202     return mult( l, n );                                              
00203   }

friend NUMBER operator * (  TYPE2    n,
const NUMBER &    r
)  [inline]
 

Definition at line 184 of file NbOperator2.hpp.

00184                                                              {       
00185     return mult( r, n );                                              
00186   }

operator TYPE2 (    )  const [inline]
 

Definition at line 216 of file NbOperator2.hpp.

00216 { return (TYPE2)value; }

friend BOOL operator!= (  TYPE2    n,
const NUMBER &    r
)  [inline]
 

Definition at line 117 of file NbOperator2.hpp.

00117                                                             {  
00118     return !isEqualTo( r, n );                                        
00119   }

friend BOOL operator!= (  const NUMBER &    l,
TYPE2    n
)  [inline]
 

Definition at line 93 of file NbOperator2.hpp.

00093                                                             {  
00094     return !isEqualTo( l, n );                                        
00095   }

friend NUMBER operator+ (  const NUMBER &    l,
TYPE2    n
)  [inline]
 

Definition at line 193 of file NbOperator2.hpp.

00193                                                              { 
00194     return add( l, n );                                               
00195   }

friend NUMBER operator+ (  TYPE2    n,
const NUMBER &    r
)  [inline]
 

Definition at line 176 of file NbOperator2.hpp.

00176                                                              {       
00177     return add( r, n );                                               
00178   }

friend NUMBER operator- (  const NUMBER &    l,
TYPE2    n
)  [inline]
 

Definition at line 197 of file NbOperator2.hpp.

00197                                                              { 
00198     return sub( l, n );                                               
00199   }

friend NUMBER operator- (  TYPE2    n,
const NUMBER &    r
)  [inline]
 

Definition at line 180 of file NbOperator2.hpp.

00180                                                              {       
00181     return sub( n, r );                                               
00182   }

friend NUMBER operator/ (  const NUMBER &    l,
TYPE2    n
)  [inline]
 

Definition at line 205 of file NbOperator2.hpp.

00205                                                              { 
00206     return div( l, n );                                               
00207   }

friend NUMBER operator/ (  TYPE2    n,
const NUMBER &    r
)  [inline]
 

Definition at line 188 of file NbOperator2.hpp.

00188                                                              {       
00189     return div( n, r );                                               
00190   }

friend BOOL operator< (  TYPE2    n,
const NUMBER &    r
)  [inline]
 

Definition at line 121 of file NbOperator2.hpp.

00121                                                             {  
00122     return  isBiggerThan( r, n );                                     
00123   }

friend BOOL operator< (  const NUMBER &    l,
TYPE2    n
)  [inline]
 

Definition at line 97 of file NbOperator2.hpp.

00097                                                             {  
00098     return  isLessThan( l, n );                                       
00099   }

friend BOOL operator<= (  TYPE2    n,
const NUMBER &    r
)  [inline]
 

Definition at line 125 of file NbOperator2.hpp.

00125                                                             {  
00126     return ( isBiggerThan( r, n ) || isEqualTo( r, n ) );             
00127   }

friend BOOL operator<= (  const NUMBER &    l,
TYPE2    n
)  [inline]
 

Definition at line 101 of file NbOperator2.hpp.

00101                                                             {  
00102     return ( isLessThan( l, n ) || isEqualTo( l, n ) );               
00103   }

const NUMBER& operator= (  TYPE2    n )  [inline]
 

Definition at line 210 of file NbOperator2.hpp.

00210                                           {                          
00211     value = (TYPE)n;                                                 
00212     state = verify( value );                                         
00213     return *this;                                                     
00214   }

friend BOOL operator== (  TYPE2    n,
const NUMBER &    r
)  [inline]
 

Definition at line 113 of file NbOperator2.hpp.

00113                                                             {  
00114     return  isEqualTo( r, n );                                        
00115   }

friend BOOL operator== (  const NUMBER &    l,
TYPE2    n
)  [inline]
 

Definition at line 89 of file NbOperator2.hpp.

00089                                                             {  
00090     return  isEqualTo( l, n );                                        
00091   }

friend BOOL operator> (  TYPE2    n,
const NUMBER &    r
)  [inline]
 

Definition at line 129 of file NbOperator2.hpp.

00129                                                             {  
00130     return  isLessThan( r, n );                                       
00131   }

friend BOOL operator> (  const NUMBER &    l,
TYPE2    n
)  [inline]
 

Definition at line 105 of file NbOperator2.hpp.

00105                                                             {  
00106     return  isBiggerThan( l, n );                                     
00107   }

friend BOOL operator>= (  TYPE2    n,
const NUMBER &    r
)  [inline]
 

Definition at line 133 of file NbOperator2.hpp.

00133                                                             {  
00134     return ( isLessThan( r, n ) || isEqualTo( r, n ) );               
00135   }

friend BOOL operator>= (  const NUMBER &    l,
TYPE2    n
)  [inline]
 

Definition at line 109 of file NbOperator2.hpp.

00109                                                             {  
00110     return ( isBiggerThan( l, n ) || isEqualTo( l, n ) );             
00111   }

friend NUMBER sub (  TYPE2    n,
const NUMBER &    r
) 
 

Definition at line 150 of file NbOperator2.hpp.

Referenced by operator-(). 

00150                                                 {              
00151     TYPE v = (TYPE)n;                                                 
00152     MathState s = MathStateSub[ (int)verify(v) ][ (int)r.state ];    
00153     return NUMBER( v - r.value, s );                                  
00154   }

friend NUMBER sub (  const NUMBER &    l,
TYPE2    n
) 
 

Definition at line 144 of file NbOperator2.hpp.

00144                                                 {              
00145     TYPE v = (TYPE)n;                                                 
00146     MathState s = MathStateSub[ (int)l.state ][ (int)verify(v) ];     
00147     return NUMBER( l.value - v, s );                                  
00148   }

Generated on Sun Oct 14 18:46:59 2001 for Standard J2K Library by doxygen1.2.11.1 written by Dimitri van Heesch, © 1997-2001