Modulo [B]asico para prueba [unit]aria de programas:
 Todo Clases Namespaces Archivos Funciones Variables 'typedefs' Valores de enumeraciones Amigas 'defines'
Clases | Namespaces | 'defines' | Funciones
Referencia del Archivo rational.h

Declara el tipo "rational". Más...

#include <iostream>
#include <cstdlib>
#include <cctype>

Ir al código fuente de este archivo.

Clases

class  rational< INT >
 La clase rational implementa las operaciones aritméticas principales para números rationales. Más...

Namespaces

namespace  std
 Definido por la biblioteca C++ estándar.

'defines'

#define rational_h
 Evita la inclusión múltiple.

Funciones

template<class NUM >
NUM mcd (NUM x, NUM y)
 Calcula el Máximo Común Divisor de los números "x" y "y".
template<class INT >
INT gcd (const INT &x, const INT &y)
 Sinónimo de mcd(x,y).
template<class NUM >
bool operator== (const rational< NUM > &x, const rational< NUM > &y)
 ¿ x == y ?.
template<class NUM >
bool operator< (const rational< NUM > &x, const rational< NUM > &y)
 ¿ x < y ?
template<class NUM >
bool operator> (const rational< NUM > &x, const rational< NUM > &y)
 ¿ x > y ?
template<class NUM >
bool operator!= (const rational< NUM > &x, const rational< NUM > &y)
 ¿ x != y ?
template<class NUM >
bool operator<= (const rational< NUM > &x, const rational< NUM > &y)
 ¿ x <= y ?
template<class NUM >
bool operator>= (const rational< NUM > &x, const rational< NUM > &y)
 ¿ x >= y ?
template<class NUM >
double real (const rational< NUM > &num)
 Convertidor a punto flotante.
template<class NUM >
long integer (const rational< NUM > &num)
 Convertidor a punto fijo.
template<class NUM >
bool check_ok (const rational< NUM > &r)
 Verifica la invariante de la clase rational.
template<class NUM >
bool check_ok_no_Rep (const rational< NUM > &r)
 Verifica la invariante de la clase rational.
template<class NUM >
ostream & operator<< (ostream &COUT, const rational< NUM > &r)
 Graba el valor de "r" en el flujo "COUT".
template<class NUM >
istream & operator>> (istream &CIN, rational< NUM > &r)
 Lee del flujo de texto "CIN" el valor de "r".
template<class NUM >
rational< NUM > operator+ (const rational< NUM > &x, const rational< NUM > &y)
 "x+y".
template<class NUM >
rational< NUM > operator- (const rational< NUM > &x, const rational< NUM > &y)
 "x-y".
template<class NUM >
rational< NUM > operator* (const rational< NUM > &x, const rational< NUM > &y)
 "x*y".
template<class NUM >
rational< NUM > operator/ (const rational< NUM > &x, const rational< NUM > &y)
 "x/y".
template<class NUM >
rational< NUM > & operator++ (rational< NUM > &r)
 ++r.
template<class NUM >
rational< NUM > operator++ (rational< NUM > &r, int)
 r++.
template<class NUM >
rational< NUM > & operator-- (rational< NUM > &r)
 --r.
template<class NUM >
rational< NUM > operator-- (rational< NUM > &r, int)
 r--.

Descripción detallada

Declara el tipo "rational".

Autor:
Adolfo Di Mare adolf.nosp@m.o@di.nosp@m.-mare.nosp@m..com
Fecha:
2005

Definición en el archivo rational.h.

Documentación de los 'defines'

#define rational_h

Evita la inclusión múltiple.

Definición en la línea 19 del archivo rational.h.

Documentación de las funciones

template<class NUM >
NUM mcd ( NUM  x,
NUM  y 
)

Calcula el Máximo Común Divisor de los números "x" y "y".

  • mcd(x,y) >= 1 siempre.
  • MCD <==> GCD: Greatest Common Divisor .
Precondición:
(y != 0)
Comentarios:
Se usa el algoritmo de Euclides para hacer el cálculo.
Ejemplo:
    2*3*5 == mcd( 2*2*2*2 * 3*3 * 5*5, 2*3*5 )
       30 == mcd( -3600, -30 )

    {{  // test::mcd()
        assertTrue( 1 == mcd(1,2) );
        assertTrue( 2*3*5 == mcd( 2*2*2*2 * 3*3 * 5*5, 2*3*5 ) );
        assertTrue( 30 == mcd( -3600, -30 ) );
    }}

Ver también:
test_rational<NUM>::test_mcd()

Definición en la línea 449 del archivo rational.h.

template<class INT >
INT gcd ( const INT &  x,
const INT &  y 
) [inline]

Sinónimo de mcd(x,y).

Definición en la línea 112 del archivo rational.h.

template<class NUM >
bool operator== ( const rational< NUM > &  x,
const rational< NUM > &  y 
) [inline]

¿ x == y ?. 

    {{  // test::op_comp()
        rational<INT> neg_half(-1,2), quarter(1,4);
        assertTrue( neg_half == -(-neg_half) );
        assertTrue( neg_half <  quarter  );
        assertTrue( quarter  >  neg_half );
        assertTrue( neg_half <= quarter  );
        assertTrue( quarter  >= neg_half );
        assertTrue( neg_half != quarter  );
    }}

Ver también:
test_rational<NUM>::test_op_comp()

Definición en la línea 254 del archivo rational.h.

template<class NUM >
bool operator< ( const rational< NUM > &  x,
const rational< NUM > &  y 
) [inline]

¿ x < y ?

Definición en la línea 266 del archivo rational.h.

template<class NUM >
bool operator> ( const rational< NUM > &  x,
const rational< NUM > &  y 
) [inline]

¿ x > y ?

Definición en la línea 289 del archivo rational.h.

template<class NUM >
bool operator!= ( const rational< NUM > &  x,
const rational< NUM > &  y 
) [inline]

¿ x != y ?

Definición en la línea 295 del archivo rational.h.

template<class NUM >
bool operator<= ( const rational< NUM > &  x,
const rational< NUM > &  y 
) [inline]

¿ x <= y ?

Definición en la línea 301 del archivo rational.h.

template<class NUM >
bool operator>= ( const rational< NUM > &  x,
const rational< NUM > &  y 
) [inline]

¿ x >= y ?

Definición en la línea 307 del archivo rational.h.

template<class NUM >
double real ( const rational< NUM > &  num) [inline]

Convertidor a punto flotante.

Definición en la línea 313 del archivo rational.h.

template<class NUM >
long integer ( const rational< NUM > &  num) [inline]

Convertidor a punto fijo.

Definición en la línea 319 del archivo rational.h.

template<class NUM >
bool check_ok ( const rational< NUM > &  r)

Verifica la invariante de la clase rational.

Rep Modelo de la clase:
    +---+
    | 3 | <==  m_num == numerador del número racional
    +---+
    |134| <==  m_den == denominador del número racional
    +---+
Comentarios:
Libera al programador de implementar el método Ok() 
    {{  // test::check_ok()
        rational<INT> r, *nul=0;      assertFalse( check_ok(*nul) );
        r.m_num =  2;  r.m_den =  0;  assertFalse( check_ok(  r ) );
        r.m_num =  2;  r.m_den = -1;  assertFalse( check_ok(  r ) );
        r.m_num =  0;  r.m_den =  2;  assertFalse( check_ok(  r ) );
        r.m_num = 31;  r.m_den = 31;  assertFalse( check_ok(  r ) );
        r.simplify();                 assertTrue ( check_ok(  r ) );
    }}

Ver también:
test_rational<NUM>::test_check_ok()
  • Invariante: ningún objeto puede estar almacenado en la posición nula.
  • Invariante: el denominador debe ser un número positivo.
  • Invariante: el cero debe representarse con denominador igual a "1".
  • Invariante: el numerador y el denominador deben ser primos relativos.

Definición en la línea 356 del archivo rational.h.

template<class NUM >
bool check_ok_no_Rep ( const rational< NUM > &  r)

Verifica la invariante de la clase rational.

Comentarios:
Esta implementación nos se le mete al Rep (casi siempre no es posible implementar una función como ésta).
Libera al programador de implementar el método Ok()
  • Invariante: ningún objeto puede estar almacenado en la posición nula.
  • Invariante: el denominador debe ser un número positivo.
  • Invariante: el cero debe representarse con denominador igual a "1".
  • Invariante: el numerador y el denominador deben ser primos relativos.

Definición en la línea 401 del archivo rational.h.

template<class NUM >
ostream& operator<< ( ostream &  COUT,
const rational< NUM > &  r 
)

Graba el valor de "r" en el flujo "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: 
              cout << r << q;

    {{  // test::op_out()
        std::basic_ostringstream<char> ost; // receptor de salida
        ost.str(""); ost << rational<INT>(-1,2);  assertTrue( ost.str() == "[-1/2]" );
        ost.str(""); ost << rational<INT>(-12);   assertTrue( ost.str() == "[-12]"  );
        ost.str(""); ost << rational<INT>(1-1,8); assertTrue( ost.str() == "[0]"    );
        ost.str(""); // Borra el receptor de salida
        ost << rational<INT>(-1,2) << rational<INT>(-12) << rational<INT>(1-1,8);
        assertTrue( ost.str() == "[-1/2][-12][0]" );
    }}

Ver también:
test_rational<NUM>::test_op_out()

Definición en la línea 543 del archivo rational.h.

template<class NUM >
istream& operator>> ( istream &  CIN,
rational< NUM > &  r 
)

Lee del flujo de texto "CIN" el valor de "r".

Precondición:
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 "]".
  • [ -+-+-+-+- 4 / -- -+ -- 32 ] se lee como [1/8] 
    {{  // test::op_in()
        std::basic_istringstream<char> ist( "[-1/2] [-12] [0]" );
        rational<INT> r(0); ist >> r;  assertTrue( r == rational<INT>(-1,2) );
        rational<INT> s(1); ist >> s;  assertTrue( s == rational<INT>(-12)  );
        rational<INT> t(2); ist >> t;  assertTrue( t == rational<INT>(0)    );

        ist.str( "[ -+-+-+-+- 4 / -- -+ -- 32  ]" );
        rational<INT> u(3); ist >> u;  assertTrue( u == rational<INT>(1,8) );
    }}

Ver también:
test_rational<NUM>::test_op_in()

Definición en la línea 566 del archivo rational.h.

template<class NUM >
rational<NUM> operator+ ( const rational< NUM > &  x,
const rational< NUM > &  y 
)

"x+y".

  • Calcula y retorna la suma "x+y".
    {{  // test::op_add()
        rational<INT> add(0), sub(0);
        for ( int i=20; i>=-20; --i ) {
            add = add + rational<INT>(i-i, 20*i+1);
            sub = sub - rational<INT>(i-i, 20*i+1);
        }
        assertTrue( add == sub );
    }}

Ver también:
test_rational<NUM>::test_op_add()

Definición en la línea 712 del archivo rational.h.

template<class NUM >
rational<NUM> operator- ( const rational< NUM > &  x,
const rational< NUM > &  y 
)

"x-y".

  • Calcula y retorna la resta "x-y".
    {{  // test::op_add()
        rational<INT> add(0), sub(0);
        for ( int i=20; i>=-20; --i ) {
            add = add + rational<INT>(i-i, 20*i+1);
            sub = sub - rational<INT>(i-i, 20*i+1);
        }
        assertTrue( add == sub );
    }}

Ver también:
test_rational<NUM>::test_op_add()

Definición en la línea 729 del archivo rational.h.

template<class NUM >
rational<NUM> operator* ( const rational< NUM > &  x,
const rational< NUM > &  y 
)

"x*y".

  • Calcula y retorna la multiplicación "x*y".
    {{  // test::op_mult()
        rational<INT> mlt(1), div(1);
        for ( int i=15; i>=-15; --i ) {
            mlt = mlt * rational<INT>(17*i-1, 13*i+1);
            div = div / rational<INT>(13*i+1, 17*i-1);
        }
        assertTrue( mlt == div );
    }}

Ver también:
test_rational<NUM>::test_op_mult()

Definición en la línea 746 del archivo rational.h.

template<class NUM >
rational<NUM> operator/ ( const rational< NUM > &  x,
const rational< NUM > &  y 
)

"x/y".

  • Calcula y retorna la división "x/y".
Precondición:
y != 0 
    {{  // test::op_mult()
        rational<INT> mlt(1), div(1);
        for ( int i=15; i>=-15; --i ) {
            mlt = mlt * rational<INT>(17*i-1, 13*i+1);
            div = div / rational<INT>(13*i+1, 17*i-1);
        }
        assertTrue( mlt == div );
    }}
Ver también:
test_rational<NUM>::test_op_mult()

Definición en la línea 764 del archivo rational.h.

template<class NUM >
rational<NUM>& operator++ ( rational< NUM > &  r) [inline]

++r. 

    {{  // test::op_cpp()
        rational<INT> r(3,2);

        assertTrue( r++ == rational<INT>(3,2) );
        assertTrue( r   == rational<INT>(5,2) );

        assertTrue( r-- == rational<INT>(5,2) );
        assertTrue( r   == rational<INT>(3,2) );

        assertTrue( --r == rational<INT>(1,2) );
    }}

Ver también:
test_rational<NUM>::test_op_cpp()

Definición en la línea 789 del archivo rational.h.

template<class NUM >
rational<NUM> operator++ ( rational< NUM > &  r,
int   
) [inline]

r++.

Definición en la línea 796 del archivo rational.h.

template<class NUM >
rational<NUM>& operator-- ( rational< NUM > &  r) [inline]

--r. 

    {{  // test::op_cpp()
        rational<INT> r(3,2);

        assertTrue( r++ == rational<INT>(3,2) );
        assertTrue( r   == rational<INT>(5,2) );

        assertTrue( r-- == rational<INT>(5,2) );
        assertTrue( r   == rational<INT>(3,2) );

        assertTrue( --r == rational<INT>(1,2) );
    }}

Ver también:
test_rational<NUM>::test_op_cpp()

Definición en la línea 809 del archivo rational.h.

template<class NUM >
rational<NUM> operator-- ( rational< NUM > &  r,
int   
) [inline]

r--.

Definición en la línea 816 del archivo rational.h.

Generado el Viernes, 25 de Mayo de 2012 08:28:10 para Modulo [B]asico para prueba [unit]aria de programas: por   doxygen 1.8.0