Site hosted by Angelfire.com: Build your free website today!
Página principal | Lista de namespace | Lista de componentes | Lista de archivos | Miembros de las clases | Archivos de los miembros

rational.h

Ir a la documentación de este archivo.
00001 // rational.h   (c) 2005 adolfo@di-mare.com
00002 
00019 #ifndef rational_h
00020 #define rational_h // evita la inclusión múltiple
00021 
00022 #ifdef __BORLANDC__
00023     #include  "bool.h"    // Usado sólo para Borland C++ v3.1
00024     #include  <iostream.h>
00025     class ostream; class istream; // para operator << y operator >>
00026 #endif
00027 
00028 #ifdef _MSC_VER
00029     #if (_MSC_VER >= 1300)
00030 
00031         namespace std {} // Está acá para que Doxygen lo documente
00032         #include  <iostream>
00033         using namespace std;
00034     #endif
00035 
00036     #if (_MSC_VER < 1300)
00037         // Antes de MSC++ .NET hay que usar <.h>
00038         #include  <iostream.h>
00039     #endif
00040 #endif
00041 
00047 class rational {
00048 private:
00049     long m_num; 
00050     long m_den; 
00051 
00052     void simplifique();
00053 
00054 public:
00055     // constructores
00056     rational() : m_num(0), m_den(1) { }  
00057     rational(long num) : m_num(num), m_den(1) { } 
00058     rational(long num, long den)
00059         : m_num(num), m_den(den) { simplifique(); } 
00060     rational(const rational& o)       
00061         { m_num = o.m_num, m_den = o.m_den; }
00062     ~rational() { }      // destructor
00063 
00064     void asigne(long num=0, long den=1);  // Le cambia el valor a \c "*this"
00065 
00066     long num() const { return m_num; }  
00067     long den() const { return m_den; }  
00068 
00069 //  void num(long n) { m_num=n; simplifique(); }  // FEO
00070 //  void den(long d) { m_den= ( d!=0 ? d : m_den) ; simplifique(); }  // FEO
00071 
00072     rational& operator  = (const rational&);  // Asignación (copia)
00073     rational& operator  = (long);
00074     rational& Swap ( rational& );
00075 
00076     rational& operator += (const rational&);
00077     rational& operator -= (const rational&);
00078     rational& operator *= (const rational&);
00079     rational& operator /= (const rational&);
00080 
00081     rational operator  - ();                    // menos unario
00082 
00083     friend rational operator + (const rational&, const rational&);
00084     friend rational operator - (const rational&, const rational&);
00085     friend rational operator * (const rational&, const rational&);
00086     friend rational operator / (const rational&, const rational&);
00087 
00088     friend bool operator == (const rational&, const rational&);
00089     friend bool operator <  (const rational&, const rational&);
00090     friend bool operator != (const rational&, const rational&);
00091     friend bool operator <= (const rational&, const rational&);
00092     friend bool operator >= (const rational&, const rational&);
00093     friend bool operator >  (const rational&, const rational&);
00094 
00095     friend ostream& operator << (ostream &, const rational& );
00096     friend istream& operator >> (istream &,       rational& );
00097 
00098     friend double real   (const rational& );   // Conversión a real
00099     friend long   integer(const rational& );   // Conversión a long
00100 
00101     friend bool check_ok( const rational& r ); // Ok()
00102 //  excluidos porque producen ambigüedad con operadores aritméticos
00103 //  operator double () { return double(m_num) / double(m_den); }
00104 //  operator long   () { return        m_num  /        m_den ; }
00105 }; // rational
00106 
00107 long mcd(long x, long y); // Calcula el Máximo Común Divisor
00108 
00109 inline long gcd(long x, long y) { return mcd(x,y); }
00110 
00112 inline void rational::asigne(long n, long d) {
00113     m_num = n;
00114     m_den = d;
00115     simplifique();
00116 }  // rational::asigne
00117 
00129 inline rational& rational::operator = (const rational& o) {
00130 // Copia
00131 
00132     m_num = o.m_num,
00133     m_den = o.m_den;
00134 
00135 //  sobra invocar a "simplifique()" pues "o" ya está simplificado
00136     return *this;
00137 }  // operator =
00138 
00148 inline rational& rational::Swap ( rational& o) {
00149     #if 1
00150         rational tmp = o;
00151         o = *this;
00152         *this = tmp;
00153     #else
00154         // Esto NO funciona para objetos, métodos virtuales, etc.
00155         char tmp[ sizeof( *this ) ];
00156         memcpy( tmp,   o,     sizeof( *this ) ); // tmp = o;
00157         memcpy( o,    *this,  sizeof( *this ) ); // o = *this;
00158         memcpy( *this, tmp,   sizeof( *this ) ); // *this = tmp;
00159     #endif
00160     return *this;
00161 }
00162 
00164 inline rational& rational::operator = (long entero) {
00165 
00166     m_num = entero;
00167     m_den = 1;
00168     return *this;
00169 }  // operator =
00170 
00172 inline rational& rational::operator *= (const rational& num) {
00173 
00174     m_num *= num.m_num;
00175     m_den *= num.m_den;
00176     simplifique();
00177     return *this;
00178 }  // operator *=
00179 
00185 inline rational& rational::operator /= (const rational& num) {
00186     m_num *= num.m_den;
00187     m_den *= num.m_num;
00188     simplifique();
00189     return *this;
00190 }  // operator /=
00191 
00196 inline rational rational::operator - () {
00197 
00198     rational tmp = (*this);  // tmp.rational( *this );
00199     tmp.m_num = - tmp.m_num;
00200     return tmp;
00201 }  // operator -
00202 
00204 inline bool operator == (const rational &x, const rational &y) {
00205     return (x.m_num == y.m_num) && (x.m_den == y.m_den);
00206 }  // operator ==
00207 
00209 inline bool operator < (const rational &x, const rational &y) {
00210     return (x.m_num * y.m_den) < (x.m_den * y.m_num);
00211 }  // operator <
00212 
00214 inline bool operator > (const rational &x, const rational &y) {
00215     return (y < x);
00216 }  // operator >
00217 
00219 inline bool operator != (const rational& x, const rational& y) {
00220     return !(x == y);
00221 }  // operator !=
00222 
00224 inline bool operator <= (const rational& x, const rational& y) {
00225     return !(y < x);
00226 }  // operator <=
00227 
00229 inline bool operator >= (const rational& x, const rational& y) {
00230     return !(x < y);
00231 }  // operator >=
00232 
00234 inline double real(const rational& num) {
00235     return double (num.m_num) / double (num.m_den);
00236 } // real()
00237 
00239 inline long integer(const rational& num) {
00240     return long   (num.m_num /          num.m_den);
00241 } // integer()
00242 
00243 #if 0
00244 inline rational::operator long() {
00245 // Convertidor a punto fijo
00246     return long (m_num / m_den);
00247 }  // rational::operator long
00248 #endif
00249 
00250 #endif // rational_h
00251 
00252 // EOF: rational.h

Generado el Tue Aug 16 17:56:40 2005 para A33018 Tarea Programada #1 por  doxygen 1.4.4