src/baseparsuif/suifmath/fract.h

   1 /* file "fract.h" */
   2
   3 /*  Copyright (c) 1994 Stanford University
   4
   5     All rights reserved.
   6
   7     This software is provided under the terms described in
   8     the "suif_copyright.h" include file. */
   9
  10 #include <suif_copyright.h>
  11
  12 /*  Fraction Definitions */
  13 #pragma interface
  14
  15 #ifndef FRACT_H
  16 #define FRACT_H
  17
  18 #pragma interface
  19
  20 /*  the following files must be included before this point:
  21 #include <assert.h>
  22 #include <stdio.h>
  23 #include <useful.h>
  24 */
  25 #include <limits.h>
  26
  27 class fract;
  28
  29 inline int fmul(int a, int b)
  30 {
  31     /* make sure the result will fit in an int */
  32     double x = (double)a * (double)b;
  33     assert((x < (double)INT_MAX) && (x > (double)INT_MIN));
  34     return a * b;
  35 }
  36
  37 inline int fadd(int a, int b)
  38 {
  39     /* make sure the result will fit in an int */
  40     double x = (double)a + (double)b;
  41     assert((x < (double)INT_MAX) && (x > (double)INT_MIN));
  42     return a + b;
  43 }
  44
  45 inline int fsub(int a, int b)
  46 {
  47     /* make sure the result will fit in an int */
  48     double x = (double)a - (double)b;
  49     assert((x < (double)INT_MAX) && (x > (double)INT_MIN));
  50     return a - b;
  51 }
  52
  53 inline int fneg(int a)
  54 {
  55     /* make sure the result will fit in an int */
  56     double x = - (double)a;
  57     assert((x < (double)INT_MAX) && (x > (double)INT_MIN));
  58     return -a;
  59 }
  60
  61 class fract {
  62     int n, d;
  63     void reduce_aux();
  64     void reduce();
  65
  66 public:
  67     fract()                             { n = 0; d = 1; }
  68     fract(const fract &f)               { n = f.n; d = f.d; }
  69     fract(int nn)                       { n = nn; d = 1; }
  70     fract(int nn, int dd)               { n = nn; d = dd; reduce(); }
  71     ~fract()                            { }
  72     int num() const                     { return n; }
  73     int denom() const                   { return d; }
  74     boolean is_zero() const             { return (n == 0); }
  75     double real() const                 { return double(n) / double(d); }
  76     boolean is_int() const              { return ((d == 1) || (d == -1)); }
  77     int integer() const                 { assert(is_int());
  78                                           return ((d < 0) ? fneg(n) : n); }
  79     void operator=(const fract &f)      { n = f.n; d = f.d; }
  80     fract operator-() const             { return fract(fneg(n), d); }
  81     fract operator+(const fract &a) const
  82                                         { return fract(fadd(fmul(n, a.d),
  83                                                             fmul(d, a.n)),
  84                                                        fmul(d, a.d)); }
  85     fract operator-(const fract &a) const
  86                                         { return *this + (-a); }
  87     fract operator*(const fract &a) const
  88                                         { return fract(fmul(n, a.n),
  89                                                        fmul(d, a.d)); }
  90     fract operator/(const fract &a) const;
  91     void operator+=(const fract &a)     { int nn = fadd(fmul(n, a.d),
  92                                                         fmul(d, a.n));
  93                                           int dd = fmul(d, a.d);
  94                                           n = nn; d = dd; reduce(); }
  95     void operator-=(const fract &a)     { int nn = fsub(fmul(n, a.d),
  96                                                         fmul(d, a.n));
  97                                           int dd = fmul(d,a.d);
  98                                           n = nn; d = dd; reduce(); }
  99     void operator*=(const fract &a)     { n = fmul(n, a.n); d = fmul(d, a.d);
 100                                           reduce(); }
 101     void operator/=(const fract &a)     { assert(a.n != 0); n = fmul(n, a.d);
 102                                           d = fmul(d, a.n); reduce(); }
 103     boolean operator==(const fract &a) const
 104                                         { return (n == a.n) && (d == a.d); }
 105     boolean operator!=(const fract &a) const
 106                                         { return (n != a.n) || (d != a.d); }
 107     boolean operator<=(const fract &a) const
 108                                         { return fmul(n, a.d) <= fmul(d, a.n); }
 109     boolean operator<(const fract &a) const
 110                                         { return fmul(n, a.d) < fmul(d, a.n); }
 111     boolean operator>=(const fract &a) const
 112                                         { return fmul(n, a.d) >= fmul(d, a.n); }
 113     boolean operator>(const fract &a) const
 114                                         { return fmul(n, a.d) > fmul(d, a.n); }
 115     fract abs() const                   { return fract((n < 0) ? fneg(n) : n,
 116                                                        d); }
 117     void print(FILE *f = stdout) const;
 118 };
 119
 120 #endif /* FRACT_H */