decimal.h

Ir a la documentación de este archivo.

// decimal.h (c) 2007

/** \file  decimal.h
    \brief Declara el tipo \c "decimal".
    - La clase \c decimal implementa las operaciones aritméticas
      principales para números de tipo entero largo.

    - Permite usar decimales en cualquier sitio en donde se puedan
      usar valores numéricos.

    \author Elsie Castro-Armando Soto
    \date   2007
*/


#ifndef decimal_h
#define decimal_h ///< Evita la inclusión múltiple

#include <iostream>
#include "BigNum.h"
#include  <cstdlib>
#include  <cctype>     // isdigit()

class decimal{
private:
    BigNum m_num; ///< Numerador
    decimal( const BigNum& res ) { m_num = res; } 


public:
    // constructores
    decimal() : m_num(0) { }  ///< Constructor de vector
    decimal(long num) : m_num(num) { } ///< Constructor a partir de un valor entero
    decimal(const decimal& o)       /// Constructor de copia
        { m_num = o.m_num; }
    ~decimal() { }      ///< Destructor


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

    decimal& operator  = (const decimal&);  // Asignación (copia)
    decimal& operator  = (long);
    decimal& swap ( decimal& );

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

    decimal operator  - () const;              // menos unario

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

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

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

}; // rational


/** Copia desde \c "o".
    - El valor anterior de \c "*this" se pierde.
    \par Complejidad:
         O( \c 1 )
    \returns *this
    \see http://www.di-mare.com/adolfo/binder/c04.htm#sc05
*/
inline decimal& decimal::operator = (const decimal& o) {
    m_num = o.m_num;
   
//  sobra invocar a "Simplify()" pues "o" ya está simplificado
    return *this;
}  // operator =

/** Intercambia los valores de \c "*this" y \c "o".
      \par Complejidad:
         O( \c 1 )

    \returns *this

    \see http://www.di-mare.com/adolfo/binder/c04.htm#sc08
*/
inline decimal& decimal::swap ( decimal& o ) {
    #if 1
        decimal 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;
}

/// Asignación desde un \c "long".
inline decimal& decimal::operator = (long entero) {
    m_num = entero;
    return *this;
}  // operator =

/// Multiplica \c "*this" por \c "num".
inline decimal& decimal::operator *= (const decimal& num) {
    BigNum m_res;

        m_res = m_num * num.m_num;
        m_num = m_res;

    return *this;
}  // operator *=

/**  Divide \c "*this" por el valor de \c "num".
    \pre
    - (num != 0)
*/
inline decimal& decimal::operator /= (const decimal& num) {//lo cambiamos
    BigNum m_res;

        m_res = m_num / num.m_num;
        m_num = m_res;

    return *this;
}  // operator /=

/// \c "-x".
/// - Menos unario
/// - Calcula y retorna el valor \c "-x"
inline decimal decimal::operator - () const {
    decimal tmp = (*this);  // tmp.rational( *this );
    tmp.m_num = - tmp.m_num;
    return tmp;
}  // operator -

/// ¿ x == y ?
inline bool operator == (const decimal &x, const decimal &y) {
    return (x.m_num == y.m_num);

}  // operator ==

/// ¿ x < y ?

inline bool operator < (const decimal &x, const decimal &y) {
    return x.m_num < y.m_num;

}  // operator <

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

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

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

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


// EOF: rational.h


/// Le suma a \c "*this" el valor de \c "otro".
decimal& decimal::operator += (const decimal& otro) {
    BigNum m_res;

        m_res = m_num + otro.m_num;
        m_num = m_res;

    return *this;
}  // operator +=


/// Le resta a \c "*this" el valor de \c "otro".
decimal& decimal::operator -= (const decimal& otro) {
    BigNum m_res;

        m_res = m_num - otro.m_num;
        m_num = m_res;

    return *this;
}  // operator -=


/** Graba el valor de \c "r" en el flujo \c "COUT".
    - Graba el valor en el formato [num/den].
    - En particular, este es el operador que se invoca
      cuando se usa, por ejemplo, este tipo de instrucción:
     \code
          cout << r << q;
     \endcode
*/
ostream& operator<< (ostream &COUT, const decimal& r) {
   
        return COUT << "[" << r.m_num << "]" ;
 
}  // operator <<

/** Lee del flujo de texto \c "CIN" el valor de \c "r".
    \pre
    El número rational debe haber sido escrito usando
    el formato "[r/den]", aunque es permisible usar
    algunos blancos.
    - Se termina de leer el valor sólo cuando encuentra \c "]".
    - <code> [ -+-+-+-+- 4 / -- -+ -- 32  ] </code> se lee como
      <code> [1/8] </code>
*/
istream& operator >> (istream &CIN, decimal& r) {
    /*char ch;  // valor leido, letra por letra, de "CIN"

    bool es_positivo = true;    // manejo de los signos + y -

    // se brinca todo hasta el primer dígito
    do {
        CIN >> ch;
        if (ch == '-') {  // cambia de signo
            es_positivo = !es_positivo;
        }
    } while (!isdigit(ch));

    // se traga el numerador
    r.m_num = 0;
    while (isdigit(ch)) { // convierte a decimal: izq --> der
        r.m_num = 10 * r.m_num + (ch-'0');
        CIN >> ch;
    }

    // se brinca los blancos después del numerador
    while (isspace(ch)) {
        CIN >> ch;
    }

    if (ch ==']') { // es un número entero
        r.m_den = 1;
    }
    else {
        do {  // se brinca todo hasta el denominador
            CIN >> ch;
            if (ch == '-') {
                es_positivo = !es_positivo;
            }
        } while (!isdigit(ch));

        // se traga el denominador
        r.m_den = 0;
        while (isdigit(ch)) {
            r.m_den = 10 * r.m_den + (ch-'0');
            CIN >> ch;
        }

        // El programa se duerme si en el flujo de entrada
        // NO aparece el caracter delimitador final "]",
        // pues la lectura termina hasta encontrar el "]".
        while (ch != ']') {
            CIN >> ch;
        }
    }   // corrección: Andrés Arias <[email protected]>


    // le cambia el signo, si hace falta
    if (! es_positivo) {
        r.m_num = -r.m_num;
    }

    return CIN;

*/
        return CIN;

}  // operator >>

/// \c "x+y".
/// - Calcula y retorna la suma \c "x+y".
decimal operator + (const decimal &x, const decimal &y) {

    return decimal(x.m_num + y.m_num);
}  // operator + ()

/// \c "x-y".

/// - Calcula y retorna la resta \c "x-y".
decimal operator - (const decimal &x, const decimal &y) {
    
        return decimal(x.m_num - y.m_num);
}  // operator - ()

/// \c "x*y".
/// - Calcula y retorna la multiplicación \c "x*y".
decimal operator * (const decimal &x, const decimal &y) {

    return decimal(x.m_num * y.m_num);
}  // operator * ()

/// \c "x/y".
/// - Calcula y retorna la división \c "x/y".
/// \pre <code> y != 0 </code>
decimal operator / (const decimal &x, const decimal &y) {
    
    return decimal(x.m_num / y.m_num);
}  // operator / ()

decimal operator % (const decimal &x, const decimal &y) {
    
    return decimal(x.m_num % y.m_num);
}  // operator / ()

#endif // rational_h

// EOF: rational.cpp

---

Hosted by www.Geocities.ws