vnl_rational.h

InsightToolkit-1.4.0(有大量的优化算法程序)

    else
      return num_ * rhs.denominator() < den_ * rhs.numerator();
  }
  inline bool operator> (vnl_rational const& r) const { return r < *this; }
  inline bool operator<= (vnl_rational const& r) const { return !operator>(r); }
  inline bool operator>= (vnl_rational const& r) const { return !operator<(r); }
  inline bool operator< (long r) const { return num_ < den_ * r; }
  inline bool operator> (long r) const { return num_ > den_ * r; }
  inline bool operator<= (long r) const { return !operator>(r); }
  inline bool operator>= (long r) const { return !operator<(r); }
  inline bool operator< (int r) const { return num_ < den_ * r; }
  inline bool operator> (int r) const { return num_ > den_ * r; }
  inline bool operator<= (int r) const { return !operator>(r); }
  inline bool operator>= (int r) const { return !operator<(r); }
  inline bool operator< (double r) const { return num_ < den_ * r; }
  inline bool operator> (double r) const { return num_ > den_ * r; }
  inline bool operator<= (double r) const { return !operator>(r); }
  inline bool operator>= (double r) const { return !operator<(r); }

  //: Converts rational value to integer by truncating towards zero.
  inline long truncate () const { assert(den_ != 0);  return num_/den_; }
  //: Converts rational value to integer by truncating towards negative infinity.
  inline long floor () const { long t = truncate();
    return num_<0L && (num_%den_) != 0 ? t-1 : t; }
  //: Converts rational value to integer by truncating towards positive infinity.
  inline long ceil () const { long t = truncate();
    return num_>0L && (num_%den_) != 0 ? t+1 : t; }
  //: Rounds rational to nearest integer.
  inline long round () const { long t = truncate();
    if (num_ < 0) return ((-num_)%den_) >= 0.5*den_ ? t-1 : t;
    else          return   (num_ %den_) >= 0.5*den_ ? t+1 : t;
  }

  // Implicit conversions
  inline operator short () {
    long t = truncate (); short r = (short)t;
    assert(r == t); // abort on underflow or overflow
    return r;
  }
  inline operator int () {
    long t = truncate (); int r = (int)t;
    assert(r == t); // abort on underflow or overflow
    return r;
  }
  inline operator long () const { return truncate(); }
  inline operator long () { return truncate(); }
  inline operator float () const { return ((float)num_)/((float)den_); }
  inline operator float () { return ((float)num_)/((float)den_); }
  inline operator double () const { return ((double)num_)/((double)den_); }
  inline operator double () { return ((double)num_)/((double)den_); }

  //: Calculate greatest common divisor of two integers.
  //  Used to simplify rational number.
  static inline long gcd (long l1, long l2) {
    while (l2!=0) { long t = l2; l2 = l1 % l2; l1 = t; }
    return l1<0 ? (-l1) : l1;
  }

private:
  //: Private function to normalize numerator/denominator of rational number.
  //  If num_ and den_ are both nonzero, their gcd is made 1 and den_ made positive.
  //  Otherwise, the nonzero den_ is set to 1 or the nonzero num_ to +1 or -1.
  inline void normalize () {
    if (num_ == 0) { den_ = 1; return; } // zero
    if (den_ == 0) { num_ = (num_>0) ? 1 : -1; return; } // +-Inf
    if (num_ != 1 && num_ != -1 && den_ != 1) {
      long common = vnl_rational::gcd (num_, den_);
      if (common != 1) { num_ /= common; den_ /= common; }
    }
    // if negative, put sign in numerator:
    if (den_ < 0) { num_ *= -1; den_ *= -1; }
  }
};

//: formatted output
// \relates vnl_rational
inline vcl_ostream& operator<< (vcl_ostream& s, vnl_rational const& r) {
  return s << r.numerator() << "/" << r.denominator();
}

//: simple input
// \relates vnl_rational
inline vcl_istream& operator>> (vcl_istream& s, vnl_rational& r) {
  long n, d; s >> n >> d;
  r.set(n,d); return s;
}

//: Returns the sum of two rational numbers.
// \relates vnl_rational
inline vnl_rational operator+ (vnl_rational const& r1, vnl_rational const& r2) {
  vnl_rational result(r1); return result += r2;
}
inline vnl_rational operator+ (vnl_rational const& r1, long r2) {
  vnl_rational result(r1); return result += r2;
}
inline vnl_rational operator+ (vnl_rational const& r1, int r2) {
  vnl_rational result(r1); return result += (long)r2;
}
inline vnl_rational operator+ (long r2, vnl_rational const& r1) {
  vnl_rational result(r1); return result += r2;
}
inline vnl_rational operator+ (int r2, vnl_rational const& r1) {
  vnl_rational result(r1); return result += (long)r2;
}

//: Returns the difference of two rational numbers.
// \relates vnl_rational
inline vnl_rational operator- (vnl_rational const& r1, vnl_rational const& r2) {
  vnl_rational result(r1); return result -= r2;
}
inline vnl_rational operator- (vnl_rational const& r1, long r2) {
  vnl_rational result(r1); return result -= r2;
}
inline vnl_rational operator- (vnl_rational const& r1, int r2) {
  vnl_rational result(r1); return result -= (long)r2;
}
inline vnl_rational operator- (long r2, vnl_rational const& r1) {
  vnl_rational result(-r1); return result += r2;
}
inline vnl_rational operator- (int r2, vnl_rational const& r1) {
  vnl_rational result(-r1); return result += (long)r2;
}

//: Returns the product of two rational numbers.
// \relates vnl_rational
inline vnl_rational operator* (vnl_rational const& r1, vnl_rational const& r2) {
  vnl_rational result(r1); return result *= r2;
}
inline vnl_rational operator* (vnl_rational const& r1, long r2) {
  vnl_rational result(r1); return result *= r2;
}
inline vnl_rational operator* (vnl_rational const& r1, int r2) {
  vnl_rational result(r1); return result *= (long)r2;
}
inline vnl_rational operator* (long r2, vnl_rational const& r1) {
  vnl_rational result(r1); return result *= r2;
}
inline vnl_rational operator* (int r2, vnl_rational const& r1) {
  vnl_rational result(r1); return result *= (long)r2;
}

//: Returns the quotient of two rational numbers.
// \relates vnl_rational
inline vnl_rational operator/ (vnl_rational const& r1, vnl_rational const& r2) {
  vnl_rational result(r1); return result /= r2;
}
inline vnl_rational operator/ (vnl_rational const& r1, long r2) {
  vnl_rational result(r1); return result /= r2;
}
inline vnl_rational operator/ (vnl_rational const& r1, int r2) {
  vnl_rational result(r1); return result /= (long)r2;
}
inline vnl_rational operator/ (long r1, vnl_rational const& r2) {
  vnl_rational result(r1); return result /= r2;
}
inline vnl_rational operator/ (int r1, vnl_rational const& r2) {
  vnl_rational result((long)r1); return result /= r2;
}

//: Returns the remainder of r1 divided by r2.
// \relates vnl_rational
inline vnl_rational operator% (vnl_rational const& r1, vnl_rational const& r2) {
  vnl_rational result(r1); return result %= r2;
}
inline vnl_rational operator% (vnl_rational const& r1, long r2) {
  vnl_rational result(r1); return result %= r2;
}
inline vnl_rational operator% (vnl_rational const& r1, int r2) {
  vnl_rational result(r1); return result %= (long)r2;
}
inline vnl_rational operator% (long r1, vnl_rational const& r2) {
  vnl_rational result(r1); return result %= r2;
}
inline vnl_rational operator% (int r1, vnl_rational const& r2) {
  vnl_rational result((long)r1); return result %= r2;
}

inline bool operator== (int  r1, vnl_rational const& r2) { return r2==r1; }
inline bool operator== (long r1, vnl_rational const& r2) { return r2==r1; }
inline bool operator!= (int  r1, vnl_rational const& r2) { return r2!=r1; }
inline bool operator!= (long r1, vnl_rational const& r2) { return r2!=r1; }
inline bool operator<  (int  r1, vnl_rational const& r2) { return r2> r1; }
inline bool operator<  (long r1, vnl_rational const& r2) { return r2> r1; }
inline bool operator>  (int  r1, vnl_rational const& r2) { return r2< r1; }
inline bool operator>  (long r1, vnl_rational const& r2) { return r2< r1; }
inline bool operator<= (int  r1, vnl_rational const& r2) { return r2>=r1; }
inline bool operator<= (long r1, vnl_rational const& r2) { return r2>=r1; }
inline bool operator>= (int  r1, vnl_rational const& r2) { return r2<=r1; }
inline bool operator>= (long r1, vnl_rational const& r2) { return r2<=r1; }

inline long truncate (vnl_rational const& r) { return r.truncate(); }
inline long floor (vnl_rational const& r) { return r.floor(); }
inline long ceil (vnl_rational const& r) { return r.ceil(); }
inline long round (vnl_rational const& r) { return r.round(); }

inline vnl_rational vnl_math_abs(vnl_rational const& x) { return x<0L ? -x : x; }
inline vnl_rational vnl_math_squared_magnitude(vnl_rational const& x) { return x*x; }
inline vnl_rational vnl_math_sqr(vnl_rational const& x) { return x*x; }
inline bool vnl_math_isnan(vnl_rational const& ){return false;}
inline bool vnl_math_isfinite(vnl_rational const& x){return x.denominator() != 0L;} 

#endif // vnl_rational_h_