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

guar::rational Class Reference

#include <guar_exact.h>

List of all members.

Public Methods

GULAPI rational (void)
GULAPI rational (int na, unsigned long *a, int sign=0)
GULAPI rational (ULong a, int sign=0)
GULAPI rational (int sign, int size_a, int size_b)
 rational (const rational &other)
GULAPI rational & operator= (const rational &other)
GULAPI ~rational ()
GULAPI rational get_copy () const
rational numerator () const
rational denominator () const
GULAPI void calc_bounds (void) const
GULAPI const Interval & get_bounds (void) const
template<class T> GULAPI void dump (T &num, T &den) const
template<class T> void dump (T &t) const
double dump () const
bool is_zero (void) const
int test (void) const
GULAPI void div_mod (rational *q, rational *r) const

Public Attributes

rational_rep * m

Friends

GULAPI friend rational operator * (const rational &a, const rational &b)
GULAPI friend rational operator+ (const rational &A, const rational &B)
GULAPI friend rational operator/ (const rational &A, const rational &B)
GULAPI friend rational operator- (const rational &A, const rational &B)

Constructor & Destructor Documentation

GULAPI guar::rational::rational (  void    ) 
 

Definition at line 470 of file guar_exact.cpp.

References GULAPI, m, and gust::PoolAlloc().

Referenced by denominator(), div_mod(), get_copy(), numerator(), rational(), and test(). 

00471 {
00472   size_t bsize;
00473   void *buf = gust::PoolAlloc( sizeof(rational_rep), &bsize );
00474   if( buf == NULL ) throw gul::PoolAllocError();
00475   m = new(buf) rational_rep;
00476 }

GULAPI guar::rational::rational (  int    na,
unsigned long *    a,
int    sign = 0
)  [explicit]
 

Definition at line 478 of file guar_exact.cpp.

References GULAPI, m, and gust::PoolAlloc(). 

00479 {
00480   size_t bsize;
00481   void *buf = gust::PoolAlloc( sizeof(rational_rep), &bsize );
00482   if( buf == NULL ) throw gul::PoolAllocError();
00483   m = new(buf) rational_rep(sign,na,a);
00484 }

GULAPI guar::rational::rational (  ULong    a,
int    sign = 0
)  [explicit]
 

Definition at line 486 of file guar_exact.cpp.

References GULAPI, m, and gust::PoolAlloc(). 

00487 {
00488   size_t bsize;
00489   void *buf = gust::PoolAlloc( sizeof(rational_rep), &bsize );
00490   if( buf == NULL ) throw gul::PoolAllocError();
00491   m = new(buf) rational_rep(sign,a);
00492 }

GULAPI guar::rational::rational (  int    sign,
int    size_a,
int    size_b
)  [explicit]
 

Definition at line 494 of file guar_exact.cpp.

References GULAPI, m, and gust::PoolAlloc(). 

00495 {
00496   size_t bsize;
00497   void *buf = gust::PoolAlloc( sizeof(rational_rep), &bsize );
00498   if( buf == NULL ) throw gul::PoolAllocError();
00499   m = new(buf) rational_rep( sign, size_a, size_b );
00500 }

guar::rational::rational (  const rational &    other )  [inline]
 

Definition at line 343 of file guar_exact.h.

References GULAPI, and rational(). 

00344   {
00345     other.m->m_refcount++;
00346     m = other.m;
00347   }

GULAPI guar::rational::~rational (  void    ) 
 

Definition at line 517 of file guar_exact.cpp.

References GULAPI, m, guar::rational::rational_rep::m_refcount, gust::PoolFree(), and guar::rational::rational_rep::~rational_rep(). 

00518 {
00519   if( --m->m_refcount == 0 ) 
00520   {
00521     m->~rational_rep();
00522     gust::PoolFree( m, sizeof(rational_rep) );      
00523   }
00524 }

Member Function Documentation

GULAPI void guar::rational::calc_bounds (  void    )  const
 

Definition at line 540 of file guar_exact.cpp.

References guar::rational::rational_rep::calc_bounds(), GULAPI, and m. 

00541 { 
00542   m->calc_bounds();
00543 }

rational guar::rational::denominator (    )  const [inline]
 

Definition at line 361 of file guar_exact.h.

References GULAPI, and rational(). 

00362   { 
00363     if( m->m_nb )
00364       return rational(m->m_nb,m->m_b,m->m_sign);
00365 
00366     return rational(ULong(1));
00367   }

GULAPI void guar::rational::div_mod (  rational *    q,
rational *    r
)  const
 

Definition at line 794 of file guar_exact.cpp.

References GULAPI, guar::IntDiv(), m, guar::rational::rational_rep::m_a, guar::rational::rational_rep::m_b, guar::rational::rational_rep::m_na, guar::rational::rational_rep::m_nb, guar::rational::rational_rep::m_sign, and rational(). 

00795 {
00796   if( (m->m_na == 0) || (m->m_nb == 0) )
00797   {
00798     *q = *this;
00799     *r = rational(); 
00800     return;
00801   }
00802   else if( m->m_na < m->m_nb ) 
00803   {
00804     *q = rational();
00805     *r = rational( 0, m->m_na, 0 );
00806     memcpy( r->m->m_a, m->m_a, m->m_na*sizeof(unsigned long) );
00807   }
00808   else 
00809   {
00810     rational Q( 0, m->m_na - m->m_nb + 1, 0 );
00811     rational R( 0, m->m_nb, 0 );
00812 
00813     if( !IntDiv( m->m_na, m->m_a, m->m_nb, m->m_b,
00814                     &Q.m->m_na, Q.m->m_a, &R.m->m_na, R.m->m_a ) )
00815       throw gul::Error();
00816 
00817     *q = Q; *r = R;
00818   }
00819 
00820   if( m->m_sign )
00821   {
00822     *q = *q + rational(ULong(1));
00823     q->m->m_sign = -1;
00824     
00825     rational h( 0, m->m_nb, 0 );
00826     memcpy( h.m->m_a, m->m_b, m->m_nb*sizeof(unsigned long) );
00827     *r = h - *r;
00828   }
00829 }

double guar::rational::dump (    )  const [inline]
 

Definition at line 382 of file guar_exact.h. 

00383   {
00384     double t;
00385     dump(t);
00386     return t;
00387   }

template<class T>
void guar::rational::dump (  T &    t )  const [inline]
 

Definition at line 374 of file guar_exact.h. 

00375   {
00376     T n,d;
00377 
00378     m->dump( n, d );
00379     
00380     t = n/d;
00381   }

template<class T>
GULAPI void guar::rational::dump (  T &    num,
T &    den
)  const
 

Definition at line 552 of file guar_exact.cpp.

References guar::rational::rational_rep::dump(), GULAPI, and m. 

00553 { 
00554   m->dump( num, den );
00555 }

GULAPI const Interval & guar::rational::get_bounds (  void    )  const
 

Definition at line 545 of file guar_exact.cpp.

References guar::rational::rational_rep::calc_bounds(), GULAPI, m, guar::rational::rational_rep::m_bounds, and guar::rational::rational_rep::m_i. 

00546 {
00547   if( !m->m_bounds ) m->calc_bounds();
00548   return(m->m_i);
00549 }

GULAPI rational guar::rational::get_copy (    )  const
 

Definition at line 526 of file guar_exact.cpp.

References GULAPI, m, guar::rational::rational_rep::m_a, guar::rational::rational_rep::m_b, guar::rational::rational_rep::m_na, guar::rational::rational_rep::m_nb, guar::rational::rational_rep::m_sign, and rational(). 

00527 {
00528   rational C(m->m_sign,m->m_na,m->m_nb);
00529   unsigned int i;
00530     
00531   if( m->m_na )
00532     for( i = 0; i < m->m_na; i++ )
00533       C.m->m_a[i] = m->m_a[i];
00534   if( m->m_nb )
00535     for( i = 0; i < m->m_nb; i++ )
00536       C.m->m_b[i] = m->m_b[i];
00537   return C;
00538 }

bool guar::rational::is_zero (  void    )  const [inline]
 

Definition at line 389 of file guar_exact.h. 

00389 { return(m->m_na == 0); }

rational guar::rational::numerator (    )  const [inline]
 

Definition at line 354 of file guar_exact.h.

References rational(). 

00355   { 
00356     if( m->m_na )
00357       return rational(m->m_na,m->m_a,m->m_sign);
00358 
00359     return rational();
00360   }

GULAPI rational & guar::rational::operator= (  const rational &    other ) 
 

Definition at line 502 of file guar_exact.cpp.

References GULAPI, m, guar::rational::rational_rep::m_refcount, gust::PoolFree(), and guar::rational::rational_rep::~rational_rep(). 

00503 {
00504   other.m->m_refcount++;
00505 
00506   if( --m->m_refcount == 0 ) 
00507   {
00508     m->~rational_rep();
00509     gust::PoolFree( m, sizeof(rational_rep) );      
00510   }
00511 
00512   m = other.m;
00513 
00514   return( *this );    
00515 }

int guar::rational::test (  void    )  const [inline]
 

Definition at line 391 of file guar_exact.h.

References GULAPI, and rational(). 

00392   {
00393     if( m->m_sign ) return(-1);
00394     else if( m->m_na == 0 ) return(0);
00395     return(1);
00396   }

Friends And Related Function Documentation

GULAPI friend rational operator * (  const rational &    a,
const rational &    b
)  [friend]
 

Definition at line 580 of file guar_exact.cpp. 

00581 {
00582   if( (a.m->m_na == 0) || (b.m->m_na == 0) )  /* a = 0 or b = 0 */
00583   {
00584     rational c;
00585     return(c);
00586   }
00587   else
00588   {
00589     rational c( a.m->m_sign ^ b.m->m_sign, 
00590                       a.m->m_na + b.m->m_na, a.m->m_nb + b.m->m_nb );
00591 
00592     IntMult( a.m->m_na, a.m->m_a, b.m->m_na, b.m->m_a, 
00593              &c.m->m_na, c.m->m_a );
00594 
00595     if( (a.m->m_nb != 0) && (b.m->m_nb != 0) )
00596     {
00597       IntMult( a.m->m_nb, a.m->m_b, b.m->m_nb, b.m->m_b, 
00598                     &c.m->m_nb, c.m->m_b );
00599     }
00600     else
00601     {
00602       if( b.m->m_nb != 0 )
00603       {
00604         memcpy( c.m->m_b, b.m->m_b, b.m->m_nb*sizeof(unsigned long) );
00605         c.m->m_nb = b.m->m_nb; 
00606       }       
00607       else if( a.m->m_nb != 0 )
00608       {
00609         memcpy( c.m->m_b, a.m->m_b, a.m->m_nb*sizeof(unsigned long) );
00610         c.m->m_nb = a.m->m_nb;
00611       }
00612     }
00613       
00614     return(c);
00615   }
00616 }

GULAPI friend rational operator+ (  const rational &    A,
const rational &    B
)  [friend]
 

Definition at line 618 of file guar_exact.cpp. 

00619 {
00620   unsigned long *a1b2,*a2b1,*a1b2_a2b1,*b1b2;
00621   unsigned int na1b2,na2b1,n_a1b2_a2b1,nb1b2;
00622   size_t size_a1b2,size_a2b1,size_a1b2_a2b1,size_b1b2;
00623   int sign,sign2;
00624   
00625   if( A.m->m_na == 0 ) return(B);
00626   if( B.m->m_na == 0 ) return(A);
00627   
00628   rational c;
00629    
00630   if( B.m->m_nb == 0 )
00631   {
00632     a1b2 = A.m->m_a;
00633     na1b2 = A.m->m_na;
00634     size_a1b2 = 0;
00635   }
00636   else
00637   {
00638     a1b2 = (unsigned long *)gust::PoolAlloc( 
00639                      (A.m->m_na+B.m->m_nb)*sizeof(unsigned long), &size_a1b2 );
00640     if( a1b2 == NULL ) throw gul::PoolAllocError();
00641     IntMult( A.m->m_na, A.m->m_a, B.m->m_nb, B.m->m_b, 
00642              &na1b2, a1b2 );
00643   }
00644 
00645   if( A.m->m_nb == 0 )
00646   {
00647     a2b1 = B.m->m_a;
00648     na2b1 = B.m->m_na;
00649     size_a2b1 = 0;
00650   }
00651   else
00652   {
00653     a2b1 = (unsigned long *)gust::PoolAlloc( 
00654                      (B.m->m_na+A.m->m_nb)*sizeof(unsigned long), &size_a2b1 );
00655     if( a2b1 == NULL ) throw gul::PoolAllocError();
00656     IntMult( B.m->m_na, B.m->m_a, A.m->m_nb, A.m->m_b, 
00657              &na2b1, a2b1 );
00658   }
00659 
00660   n_a1b2_a2b1 = na1b2 > na2b1 ? na1b2 : na2b1;
00661   if( n_a1b2_a2b1 == 0 )
00662   {
00663     if( size_a1b2 ) gust::PoolFree( a1b2, size_a1b2 );
00664     if( size_a2b1 ) gust::PoolFree( a2b1, size_a2b1 );
00665     return(c);
00666   }
00667 
00668   sign = A.m->m_sign ^ B.m->m_sign;
00669   if( !sign ) n_a1b2_a2b1++; 
00670 
00671   a1b2_a2b1 = (unsigned long *)gust::PoolAlloc( 
00672                  n_a1b2_a2b1*sizeof(unsigned long), &size_a1b2_a2b1 );
00673   if( a1b2_a2b1 == NULL ) throw gul::PoolAllocError();
00674 
00675   if( sign )
00676   {
00677     sign2 = IntSub( na1b2, a1b2, na2b1, a2b1, &n_a1b2_a2b1, a1b2_a2b1 );
00678     if( n_a1b2_a2b1 == 0 ) 
00679     {
00680       gust::PoolFree( a1b2_a2b1, size_a1b2_a2b1 );
00681       a1b2_a2b1 = NULL;
00682     }
00683   }
00684   else
00685   {
00686     sign2 = 0;
00687     IntAdd( na1b2, a1b2, na2b1, a2b1, &n_a1b2_a2b1, a1b2_a2b1 );
00688   }
00689 
00690   if( size_a1b2 ) gust::PoolFree( a1b2, size_a1b2 );
00691   if( size_a2b1 ) gust::PoolFree( a2b1, size_a2b1 );
00692   
00693   if( n_a1b2_a2b1 == 0 )  /* numerator = 0 */
00694   {
00695     sign = 0;
00696     b1b2 = NULL;
00697     nb1b2 = 0;
00698     size_b1b2 = 0;
00699   }
00700   else                    /* numerator != 0 */
00701   {  
00702     if( A.m->m_sign )
00703       sign = sign2 ^ -1;
00704     else
00705       sign = sign2;
00706      
00707     if( A.m->m_nb == 0 )
00708     {
00709       if( B.m->m_nb == 0 )
00710       {
00711         b1b2 = NULL;
00712         nb1b2 = 0;
00713         size_b1b2 = 0;
00714       }
00715       else
00716       {
00717         nb1b2 = B.m->m_nb;
00718         b1b2 = (unsigned long *)gust::PoolAlloc( 
00719                                     nb1b2*sizeof(unsigned long), &size_b1b2 );
00720         if( b1b2 == NULL ) throw gul::PoolAllocError();
00721         memcpy( b1b2, B.m->m_b, nb1b2*sizeof(unsigned long) );
00722       }
00723     }
00724     else if( B.m->m_nb == 0 )
00725     {
00726       nb1b2 = A.m->m_nb;
00727       b1b2 = (unsigned long *)gust::PoolAlloc( 
00728                                     nb1b2*sizeof(unsigned long), &size_b1b2 );
00729       if( b1b2 == NULL ) throw gul::PoolAllocError();
00730       memcpy( b1b2, A.m->m_b, nb1b2*sizeof(unsigned long) );
00731     }
00732     else
00733     {
00734       b1b2 = (unsigned long *)gust::PoolAlloc( 
00735                 (A.m->m_nb+B.m->m_nb)*sizeof(unsigned long), &size_b1b2 );
00736       if( b1b2 == NULL ) throw gul::PoolAllocError();
00737   
00738       IntMult( A.m->m_nb, A.m->m_b, B.m->m_nb, B.m->m_b,
00739                &nb1b2, b1b2 );
00740     }
00741   }
00742   
00743   c.m->m_sign = sign;
00744   c.m->m_na = n_a1b2_a2b1;
00745   c.m->m_size_a = size_a1b2_a2b1;
00746   c.m->m_a = a1b2_a2b1;
00747   c.m->m_nb = nb1b2;
00748   c.m->m_size_b = size_b1b2;
00749   c.m->m_b = b1b2;
00750   return(c);
00751 }

GULAPI friend rational operator- (  const rational &    A,
const rational &    B
)  [friend]
 

Definition at line 767 of file guar_exact.cpp. 

00768 {
00769   rational c;  // (= 0)
00770 
00771   if( A.m == B.m )
00772     return c;
00773 
00774   if( A.m->m_na == 0 )   /* if A=0, A+B returns B !!! */
00775   {
00776     if( B.m->m_na != 0 )
00777     {
00778       c = B.get_copy();
00779       c.m->m_sign = B.m->m_sign ^ -1;
00780     }
00781     return c;
00782   }
00783     
00784   B.m->negative();
00785   c = A + B;
00786   B.m->negative();
00787 
00788   return(c);
00789 }

GULAPI friend rational operator/ (  const rational &    A,
const rational &    B
)  [friend]
 

Definition at line 753 of file guar_exact.cpp. 

00754 {
00755   rational c;
00756   
00757   if( A.m == B.m )
00758     return rational(ULong(1));
00759   
00760   B.m->reciprocal();
00761   c = A * B;
00762   B.m->reciprocal();
00763 
00764   return(c);
00765 }

Member Data Documentation

rational_rep* guar::rational::m
 

Definition at line 336 of file guar_exact.h.

Referenced by calc_bounds(), div_mod(), dump(), get_bounds(), get_copy(), operator=(), rational(), and ~rational().

The documentation for this class was generated from the following files:
Generated on Mon Jan 21 04:17:48 2002 for GUL 0.6 - Geometry Utility Library by doxygen1.2.13.1 written by Dimitri van Heesch, © 1997-2001