vnl_bignum.h

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

  inline bool operator!=(vnl_bignum const& r) const { return !operator==(r); }
  inline bool operator> (vnl_bignum const& r) const { return r<(*this); }
  inline bool operator<=(vnl_bignum const& r) const { return !operator>(r); }
  inline bool operator>=(vnl_bignum const& r) const { return !operator<(r); }
  inline bool operator==(long r) const { return operator==(vnl_bignum(r)); }
  inline bool operator!=(long r) const { return !operator==(vnl_bignum(r)); }
  inline bool operator< (long r) const { return operator<(vnl_bignum(r)); }
  inline bool operator> (long r) const { return vnl_bignum(r) < (*this); }
  inline bool operator<=(long r) const { return !operator>(vnl_bignum(r)); }
  inline bool operator>=(long r) const { return !operator<(vnl_bignum(r)); }
  inline bool operator==(int r) const { return operator==(long(r)); }
  inline bool operator!=(int r) const { return !operator==(long(r)); }
  inline bool operator< (int r) const { return operator<(long(r)); }
  inline bool operator> (int r) const { return vnl_bignum(long(r)) < (*this); }
  inline bool operator<=(int r) const { return !operator>(long(r)); }
  inline bool operator>=(int r) const { return !operator<(long(r)); }
  inline bool operator==(double r) const { return r == operator double(); }
  inline bool operator!=(double r) const { return r != operator double(); }
  inline bool operator< (double r) const { return r > operator double(); }
  inline bool operator> (double r) const { return r < operator double(); }
  inline bool operator<=(double r) const { return r >= operator double(); }
  inline bool operator>=(double r) const { return r <= operator double(); }
  inline bool operator==(long double r) const { return r == operator long double(); }
  inline bool operator!=(long double r) const { return r != operator long double(); }
  inline bool operator< (long double r) const { return r > operator long double(); }
  inline bool operator> (long double r) const { return r < operator long double(); }
  inline bool operator<=(long double r) const { return r >= operator long double(); }
  inline bool operator>=(long double r) const { return r <= operator long double(); }

  inline vnl_bignum abs() const { return operator<(0L) ? operator-() : *this; }

  // "+/-Inf" is represented as: count=1, data[0]=0, sign=+/-1 :
  inline bool is_infinity() const { return count==1 && data[0]==0; }
  inline bool is_plus_infinity() const { return is_infinity() && sign==1; }
  inline bool is_minus_infinity() const { return is_infinity() && sign==-1; }

  void dump(vcl_ostream& = vcl_cout) const;     // Dump contents of vnl_bignum

  friend int magnitude_cmp(const vnl_bignum&, const vnl_bignum&);
  friend void add(const vnl_bignum&, const vnl_bignum&, vnl_bignum&);
  friend void subtract(const vnl_bignum&, const vnl_bignum&, vnl_bignum&);
  friend void multiply_aux(const vnl_bignum&, unsigned short, vnl_bignum&, unsigned short);
  friend unsigned short normalize(const vnl_bignum&, const vnl_bignum&, vnl_bignum&, vnl_bignum&);
  friend void divide_aux(const vnl_bignum&, unsigned short, vnl_bignum&, unsigned short&);
  friend unsigned short estimate_q_hat(const vnl_bignum&, const vnl_bignum&, unsigned short);
  friend unsigned short multiply_subtract(vnl_bignum&, const vnl_bignum&, unsigned short, unsigned short);
  friend void divide(const vnl_bignum&, const vnl_bignum&, vnl_bignum&, vnl_bignum&);
  friend vnl_bignum left_shift(const vnl_bignum& b1, int l);
  friend vnl_bignum right_shift(const vnl_bignum& b1, int l);
  friend vcl_ostream& operator<< (vcl_ostream&, const vnl_bignum&);
  friend vcl_istream& operator>> (vcl_istream&, vnl_bignum&);
  friend vcl_string& vnl_bignum_to_string (vcl_string& s, const vnl_bignum& b);
  friend vnl_bignum& vnl_bignum_from_string (vnl_bignum& b, const vcl_string& s);

private:
  void xtoBigNum(const char *s);       // convert hex to vnl_bignum
  int  dtoBigNum(const char *s);       // convert decimal to vnl_bignum
  void otoBigNum(const char *s);       // convert octal to vnl_bignum
  void exptoBigNum(const char *s);     // convert exponential to vnl_bignum

  void resize(short);                  // Resize vnl_bignum data
  vnl_bignum& trim();                  // Trim vnl_bignum data
};


//: Convert the number to a decimal representation in a string.
// \relates vnl_bignum
vcl_string& vnl_bignum_to_string (vcl_string& s, const vnl_bignum& b);

//: Convert the number from a decimal representation in a string.
// \relates vnl_bignum
vnl_bignum& vnl_bignum_from_string (vnl_bignum& b, const vcl_string& s);

//: Returns the sum of two bignum numbers.
// \relates vnl_bignum
inline vnl_bignum operator+(vnl_bignum const& r1, long r2) { return r1+vnl_bignum(r2); }
inline vnl_bignum operator+(vnl_bignum const& r1, int r2) { return r1+long(r2); }
inline vnl_bignum operator+(vnl_bignum const& r1, double r2) { return r1+vnl_bignum(r2); }
inline vnl_bignum operator+(vnl_bignum const& r1, long double r2) { return r1+vnl_bignum(r2); }
inline vnl_bignum operator+(long r2, vnl_bignum const& r1) { return r1 + r2; }
inline vnl_bignum operator+(int r2, vnl_bignum const& r1) { return r1 + r2; }
inline vnl_bignum operator+(double r2, vnl_bignum const& r1) { return r1 + r2; }
inline vnl_bignum operator+(long double r2, vnl_bignum const& r1) { return r1 + r2; }

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

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

//: Returns the division of two bignum numbers.
// \relates vnl_bignum
inline vnl_bignum operator/(vnl_bignum const& r1, vnl_bignum const& r2) {
  vnl_bignum result(r1); return result /= r2;
}
inline vnl_bignum operator/(vnl_bignum const& r1, long r2) {
  vnl_bignum result(r1); return result /= r2;
}
inline vnl_bignum operator/(vnl_bignum const& r1, int r2) {
  vnl_bignum result(r1); return result /= (long)r2;
}
inline vnl_bignum operator/(vnl_bignum const& r1, double r2) {
  vnl_bignum result(r1); return result /= (vnl_bignum)r2;
}
inline vnl_bignum operator/(vnl_bignum const& r1, long double r2) {
  vnl_bignum result(r1); return result /= (vnl_bignum)r2;
}
inline vnl_bignum operator/(long r1, vnl_bignum const& r2) {
  vnl_bignum result(r1); return result /= r2;
}
inline vnl_bignum operator/(int r1, vnl_bignum const& r2) {
  vnl_bignum result((long)r1); return result /= r2;
}
inline vnl_bignum operator/(double r1, vnl_bignum const& r2) {
  vnl_bignum result(r1); return result /= r2;
}
inline vnl_bignum operator/(long double r1, vnl_bignum const& r2) {
  vnl_bignum result(r1); return result /= r2;
}

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

// Miscellaneous operators and functions

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

inline vnl_bignum vnl_math_abs(vnl_bignum const& x) { return x.abs(); }
inline vnl_bignum vnl_math_squared_magnitude(vnl_bignum const& x) { return x*x; }
inline vnl_bignum vnl_math_sqr(vnl_bignum const& x) { return x*x; }
inline bool vnl_math_isnan(vnl_bignum const& ) { return false; }
inline bool vnl_math_isfinite(vnl_bignum const& x) { return ! x.is_infinity(); }

#endif // vnl_bignum_h_