Métodos públicos | Métodos privados | Atributos privados | Amigas

Referencia de la plantilla de la Clase rational< INT >

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

#include <rational.h>

Lista de todos los miembros.

Métodos públicos

 rational ()
 Constructor de vector.
 rational (INT num)
 Constructor a partir de un valor entero.
 rational (INT num, INT den)
 Constructor a partir de un valor quedbrado.
 rational (const rational &o)
 Constructor de copia.
 ~rational ()
 Destructor.
void set (const INT &n=INT(0), const INT &d=INT(1))
 Cambia el valor del número rational a "n/d".
const INT & num () const
 Acceso al numerador.
const INT & den () const
 Acceso al denomirador (siempre >0).
rational & operator= (const rational &)
 Copia desde "o".
rational & operator= (INT)
 Asignación desde un "INT".
rational & swap (rational &)
 Intercambia los valores de "*this" y "o".
rational & operator+= (const rational &)
 Le suma a "*this" el valor de "otro".
rational & operator-= (const rational &)
 Le resta a "*this" el valor de "otro".
rational & operator*= (const rational &)
 Multiplica "*this" por "num".
rational & operator/= (const rational &)
 Divide "*this" por el valor de "num".
rational operator- () const
 "-x".
rational & fromString (const char *nStr)
 Establece el varlor de "*this" a partir de la hilera "nStr".

Métodos privados

void simplify ()
 Simplifica el numerador y el denomidador.

Atributos privados

INT m_num
 Numerador.
INT m_den
 Denominador.

Amigas

class test_rational
 Datos de prueba para la clase.
template<class NUM >
rational< NUM > operator+ (const rational< NUM > &, const rational< NUM > &)
 "x+y".
template<class NUM >
rational< NUM > operator- (const rational< NUM > &, const rational< NUM > &)
 "x-y".
template<class NUM >
rational< NUM > operator* (const rational< NUM > &, const rational< NUM > &)
 "x*y".
template<class NUM >
rational< NUM > operator/ (const rational< NUM > &, const rational< NUM > &)
 "x/y".
template<class NUM >
bool operator== (const rational< NUM > &, const rational< NUM > &)
 Â¿ x == y ?.
template<class NUM >
bool operator< (const rational< NUM > &, const rational< NUM > &)
 Â¿ x < y ?
template<class NUM >
bool operator!= (const rational< NUM > &, const rational< NUM > &)
 Â¿ x != y ?
template<class NUM >
bool operator<= (const rational< NUM > &, const rational< NUM > &)
 Â¿ x <= y ?
template<class NUM >
bool operator>= (const rational< NUM > &, const rational< NUM > &)
 Â¿ x >= y ?
template<class NUM >
bool operator> (const rational< NUM > &, const rational< NUM > &)
 Â¿ 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--.
template<class NUM >
ostream & operator<< (ostream &, const rational< NUM > &)
 Graba el valor de "r" en el flujo "COUT".
template<class NUM >
istream & operator>> (istream &, rational< NUM > &)
 Lee del flujo de texto "CIN" el valor de "r".
template<class NUM >
double real (const rational< NUM > &)
 Convertidor a punto flotante.
template<class NUM >
long integer (const rational< NUM > &)
 Convertidor a punto fijo.
template<class NUM >
bool check_ok (const rational< NUM > &r)
 Verifica la invariante de la clase rational.

Descripción detallada

template<class INT>
class rational< INT >

La clase rational implementa las operaciones aritméticas principales para números rationales.

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

Documentación del constructor y destructor

template<class INT>
rational< INT >::rational (  )  [inline]

Constructor de vector.

Ver también:
test_rational<NUM>::test_constructor().

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

template<class INT>
rational< INT >::rational ( INT  num  )  [inline]

Constructor a partir de un valor entero.

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

template<class INT>
rational< INT >::rational ( INT  num,
INT  den 
) [inline]

Constructor a partir de un valor quedbrado.

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

template<class INT>
rational< INT >::rational ( const rational< INT > &  o  )  [inline]

Constructor de copia.

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

template<class INT>
rational< INT >::~rational (  )  [inline]

Destructor.

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

Documentación de las funciones miembro

template<class NUM >
void rational< NUM >::simplify (  )  [private]

Simplifica el numerador y el denomidador.

  • Transforma el número rational de manera que el numerador y el denominador sean primos relativos, asegurando además que el denominador es siempre positivo.
  • Si (m_num==0) ==> (m_den==1).
  • Simplifica la fracción para que m_num y m_den sean números primos relativos ie, mcd(m_num,m_den) == 1.
  • Asegura que m_den sea un número positivo.
  • Restaura la invariante de la clase rational.
    {{  // test::simplify()
        rational<INT> half(1,2);
        half.m_num *= 23;
        half.m_den *= 23;
        assertTrue( half != rational<INT>(23, 23*2) );
        half.simplify();
        assertTrue( half == rational<INT>(23, 23*2) );
    }}

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

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

template<class INT >
void rational< INT >::set ( const INT &  n = INT(0),
const INT &  d = INT(1) 
) [inline]

Cambia el valor del número rational a "n/d".

Precondición:
d != 0 .
    {{  // test::set()
        rational<INT> r;
        assertTrue( r == rational<INT>( 0 ) );
        r.set(-3, -4);
        assertTrue( r == rational<INT>( 3*11 , 4*11 ) );
    }}

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

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

template<class INT>
const INT& rational< INT >::num (  )  const [inline]

Acceso al numerador. 

    {{  // test::num_den()
        rational<INT> r;       assertTrue( r.num() ==  0 && r.den() == 1 );
        r.set( -1*13, -4*13 ); assertTrue( r.num() ==  1 && r.den() == 4 );
        r.set( -2*11,  5*11 ); assertTrue( r.num() == -2 && r.den() == 5 );
        r.set(  2*17, -6*17 ); assertTrue( r.num() == -1 && r.den() == 3 );
    }}

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

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

template<class INT>
const INT& rational< INT >::den (  )  const [inline]

Acceso al denomirador (siempre >0).

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

template<class INT >
rational< INT > & rational< INT >::operator= ( const rational< INT > &  o  )  [inline]

Copia desde "o".

  • El valor anterior de "*this" se pierde.
Complejidad:
O( 1 )
Devuelve:
*this
Ver también:
http://www.di-mare.com/adolfo/binder/c04.htm#sc05
    {{  // test::op_equal()
        rational<INT> r(1), s(18,56); assertTrue( r == rational<INT>(1) );
        r = s;                        assertTrue( r == ( r / ( r / s ) ) );
        r = 34;                       assertTrue( r == rational<INT>(34) );
        s = -3;                       assertTrue( s == rational<INT>(-3) );
    }}

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

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

template<class INT >
rational< INT > & rational< INT >::operator= ( INT  entero  )  [inline]

Asignación desde un "INT". 

    {{  // test::op_equal()
        rational<INT> r(1), s(18,56); assertTrue( r == rational<INT>(1) );
        r = s;                        assertTrue( r == ( r / ( r / s ) ) );
        r = 34;                       assertTrue( r == rational<INT>(34) );
        s = -3;                       assertTrue( s == rational<INT>(-3) );
    }}

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

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

template<class INT >
rational< INT > & rational< INT >::swap ( rational< INT > &  o  )  [inline]

Intercambia los valores de "*this" y "o".

Complejidad:
O( 1 )
Devuelve:
*this
Ver también:
http://www.di-mare.com/adolfo/binder/c04.htm#sc08
    {{  // test::swap()
        rational<INT> r, s(18,56);  assertTrue( r == rational<INT>(0) );
        r.swap( s );                assertTrue( s == rational<INT>(0) );
        assertTrue( r == rational<INT>(18,56) );
    }}

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

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

template<class INT >
rational< INT > & rational< INT >::operator+= ( const rational< INT > &  otro  ) 

Le suma a "*this" el valor de "otro". 

    {{  // test::op_add_equal()
        rational<INT> add(0), sub(0);
        for ( int i=20; i>=-20; --i ) {
            add += rational<INT>(i-i, 20*i+1);
            sub -= rational<INT>(i-i, 20*i+1);
        }
        assertTrue( add == sub );
    }}

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

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

template<class INT >
rational< INT > & rational< INT >::operator-= ( const rational< INT > &  otro  ) 

Le resta a "*this" el valor de "otro". 

    {{  // test::op_add_equal()
        rational<INT> add(0), sub(0);
        for ( int i=20; i>=-20; --i ) {
            add += rational<INT>(i-i, 20*i+1);
            sub -= rational<INT>(i-i, 20*i+1);
        }
        assertTrue( add == sub );
    }}

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

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

template<class INT >
rational< INT > & rational< INT >::operator*= ( const rational< INT > &  num  )  [inline]

Multiplica "*this" por "num". 

    {{  // test::op_mult_equal()
        rational<INT> mlt(1), div(1);
        for ( int i=15; i>=-15; --i ) {
            mlt *= rational<INT>(17*i-1, 13*i+1);
            div /= rational<INT>(13*i+1, 17*i-1);
        }
        assertTrue( mlt == div );
    }}

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

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

template<class INT >
rational< INT > & rational< INT >::operator/= ( const rational< INT > &  num  )  [inline]

Divide "*this" por el valor de "num".

Precondición:
(num != 0)
    {{  // test::op_mult_equal()
        rational<INT> mlt(1), div(1);
        for ( int i=15; i>=-15; --i ) {
            mlt *= rational<INT>(17*i-1, 13*i+1);
            div /= rational<INT>(13*i+1, 17*i-1);
        }
        assertTrue( mlt == div );
    }}

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

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

template<class INT >
rational< INT > rational< INT >::operator- (  )  const [inline]

"-x".

  • Menos unario.
  • Calcula y retorna el valor "-x".
    {{  // test::op_minus()
        rational<INT> half_n(1,-2), quarter_n(-1,4);
        assertTrue( - half_n == rational<INT>(-1) * half_n );
        assertTrue( half_n * half_n == - quarter_n );
        assertTrue( half_n * half_n * half_n == - quarter_n * half_n );
    }}

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

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

template<class NUM >
rational< NUM > & rational< NUM >::fromString ( const char *  nStr  ) 

Establece el varlor de "*this" a partir de la hilera "nStr".

Precondición:
"nStr" debe estar escrita en el formato "[num/den]".
    {{  // test::fromString()
        rational<INT> r, half(1,2), quarter(1,4);
        assertTrue( - half  == r.fromString(  "[---12/24]" ) );
        assertTrue( quarter == r.fromString( "[ -03/ -12 ]") );
        r.fromString( "[ -+-+-+-+- 4 / -- -+ -- 32  ]" );
        assertTrue( r == rational<INT>(1,8) );
    }}

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

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

Documentación de las funciones relacionadas y clases amigas

template<class INT>
friend class test_rational [friend]

Datos de prueba para la clase.

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

template<class INT>
template<class NUM >
rational<NUM> operator+ ( const rational< NUM > &  x,
const rational< NUM > &  y 
) [friend]

"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 INT>
template<class NUM >
rational<NUM> operator- ( const rational< NUM > &  x,
const rational< NUM > &  y 
) [friend]

"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 INT>
template<class NUM >
rational<NUM> operator* ( const rational< NUM > &  x,
const rational< NUM > &  y 
) [friend]

"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 INT>
template<class NUM >
rational<NUM> operator/ ( const rational< NUM > &  x,
const rational< NUM > &  y 
) [friend]

"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 INT>
template<class NUM >
bool operator== ( const rational< NUM > &  x,
const rational< NUM > &  y 
) [friend]

¿ 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 INT>
template<class NUM >
bool operator< ( const rational< NUM > &  x,
const rational< NUM > &  y 
) [friend]

¿ x < y ?

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

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

¿ x != y ?

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

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

¿ x <= y ?

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

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

¿ x >= y ?

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

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

¿ x > y ?

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

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

++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 INT>
template<class NUM >
rational<NUM> operator++ ( rational< NUM > &  r,
int   
) [friend]

r++.

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

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

--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 INT>
template<class NUM >
rational<NUM> operator-- ( rational< NUM > &  r,
int   
) [friend]

r--.

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

template<class INT>
template<class NUM >
ostream& operator<< ( ostream &  COUT,
const rational< NUM > &  r 
) [friend]

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 INT>
template<class NUM >
istream& operator>> ( istream &  CIN,
rational< NUM > &  r 
) [friend]

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 INT>
template<class NUM >
double real ( const rational< NUM > &  num  )  [friend]

Convertidor a punto flotante.

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

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

Convertidor a punto fijo.

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

template<class INT>
template<class NUM >
bool check_ok ( const rational< NUM > &  r  )  [friend]

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.

Documentación de los datos miembro

template<class INT>
INT rational< INT >::m_num [private]

Numerador.

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

template<class INT>
INT rational< INT >::m_den [private]

Denominador.

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

La documentación para esta clase fue generada a partir del siguiente fichero:
 Todo Clases Namespaces Archivos Funciones Variables 'typedefs' Amigas 'defines'
Generado el Miércoles, 18 de Agosto de 2010 14:27:06 para Prueba de la clase rational<>: por  doxygen 1.7.1