rational.h

Ir a la documentación de este archivo.

// rational.h   (c) 2005 [email protected] --> Lo dejo aquí para mantener al autor original

#ifndef rational_h
#define rational_h  // evita la inclusión múltiple

#ifdef __BORLANDC__
    #include  "bool.h"    // Usado sólo para Borland C++ v3.1
    #include  <iostream.h>
    class ostream; class istream; // para operator << y operator >>
#endif

#ifdef _MSC_VER
    #if (_MSC_VER >= 1300)

        namespace std {} // Está acá para que Doxygen lo documente
        #include  <iostream>
        using namespace std;
    #endif

    #if (_MSC_VER < 1300)
        // Antes de MSC++ .NET hay que usar <.h>
        #include  <iostream.h>
    #endif
#endif

class rational {
private:
    long m_num; 
    long m_den; 

    void simplifique();

public:
    // constructores
    rational() : m_num(0), m_den(1) { }  
    rational(long num) : m_num(num), m_den(1) { } 
    rational(long num, long den)
        : m_num(num), m_den(den) { simplifique(); } 
    rational(const rational& o)       
        { m_num = o.m_num, m_den = o.m_den; }
    ~rational() { }      // destructor

    void asigne(long num=0, long den=1);  // Le cambia el valor a \c "*this"

    long num() const { return m_num; }  
    long den() const { return m_den; }  

//  void num(long n) { m_num=n; simplifique(); }  // FEO
//  void den(long d) { m_den= ( d!=0 ? d : m_den) ; simplifique(); }  // FEO

    rational& operator  = (const rational&);  // Asignación (copia)
    rational& operator  = (long);
    rational& Swap ( rational& );

    rational& operator += (const rational&);
    rational& operator -= (const rational&);
    rational& operator *= (const rational&);
    rational& operator /= (const rational&);

    rational operator  - ();                    // menos unario

    friend rational operator + (const rational&, const rational&);
    friend rational operator - (const rational&, const rational&);
    friend rational operator * (const rational&, const rational&);
    friend rational operator / (const rational&, const rational&);

    friend bool operator == (const rational&, const rational&);
    friend bool operator <  (const rational&, const rational&);
    friend bool operator != (const rational&, const rational&);
    friend bool operator <= (const rational&, const rational&);
    friend bool operator >= (const rational&, const rational&);
    friend bool operator >  (const rational&, const rational&);

    friend ostream& operator << (ostream &, const rational& );
    friend istream& operator >> (istream &,       rational& );

    friend double real   (const rational& );   // Conversión a real
    friend long   integer(const rational& );   // Conversión a long

    friend bool check_ok( const rational& r ); // Ok()
//  excluidos porque producen ambigüedad con operadores aritméticos
//  operator double () { return double(m_num) / double(m_den); }
//  operator long   () { return        m_num  /        m_den ; }
}; // rational

long mcd(long x, long y); // Calcula el Máximo Común Divisor

inline long gcd(long x, long y) { return mcd(x,y); }

inline void rational::asigne(long n, long d) {
    m_num = n;
    m_den = d;
    simplifique();
}  // rational::asigne

inline rational& rational::operator = (const rational& o) {
// Copia

    m_num = o.m_num,
    m_den = o.m_den;

//  sobra invocar a "simplifique()" pues "o" ya está simplificado
    return *this;
}  // operator =

inline rational& rational::Swap ( rational& o) {
    #if 1
        rational tmp = o;
        o = *this;
        *this = tmp;
    #else
        // Esto NO funciona para objetos, métodos virtuales, etc.
        char tmp[ sizeof( *this ) ];
        memcpy( tmp,   o,     sizeof( *this ) ); // tmp = o;
        memcpy( o,    *this,  sizeof( *this ) ); // o = *this;
        memcpy( *this, tmp,   sizeof( *this ) ); // *this = tmp;
    #endif
    return *this;
}

inline rational& rational::operator = (long entero) {

    m_num = entero;
    m_den = 1;
    return *this;
}  // operator =

inline rational& rational::operator *= (const rational& num) {

    m_num *= num.m_num;
    m_den *= num.m_den;
    simplifique();
    return *this;
}  // operator *=

inline rational& rational::operator /= (const rational& num) {
    m_num *= num.m_den;
    m_den *= num.m_num;
    simplifique();
    return *this;
}  // operator /=

inline rational rational::operator - () {

    rational tmp = (*this);  // tmp.rational( *this );
    tmp.m_num = - tmp.m_num;
    return tmp;
}  // operator -

inline bool operator == (const rational &x, const rational &y) {
    return (x.m_num == y.m_num) && (x.m_den == y.m_den);
}  // operator ==

inline bool operator < (const rational &x, const rational &y) {
    return (x.m_num * y.m_den) < (x.m_den * y.m_num);
}  // operator <

inline bool operator > (const rational &x, const rational &y) {
    return (y < x);
}  // operator >

inline bool operator != (const rational& x, const rational& y) {
    return !(x == y);
}  // operator !=

inline bool operator <= (const rational& x, const rational& y) {
    return !(y < x);
}  // operator <=

inline bool operator >= (const rational& x, const rational& y) {
    return !(x < y);
}  // operator >=

inline double real(const rational& num) {
    return double (num.m_num) / double (num.m_den);
} // real()

inline long integer(const rational& num) {
    return long   (num.m_num /          num.m_den);
} // integer()

#if 0
inline rational::operator long() {
// Convertidor a punto fijo
    return long (m_num / m_den);
}  // rational::operator long
#endif

#endif // rational_h

// EOF: rational.h

---

Hosted by www.Geocities.ws