/Users/garethloy/Musimathics/Musimat1.2/include/Rational.h

Go to the documentation of this file.

/* $Revision: 1.5 $ $Date: 2006/09/08 18:56:52 $ $Author: dgl $ $Name:  $ $Id: Rational.h,v 1.5 2006/09/08 18:56:52 dgl Exp $ */
#ifndef Rational_H
#define Rational_H

// The Musimat Tutorial � 2006 Gareth Loy
// Derived from Chapter 9 and Appendix B of "Musimathics Vol. 1" � 2006 Gareth Loy 
// and published exclusively by The MIT Press.
// This program is released WITHOUT ANY WARRANTY; without even the implied 
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
// For information on usage and redistribution, and for a DISCLAIMER OF ALL
// WARRANTIES, see the file, "LICENSE.txt," in this distribution.
// "Musimathics" is available here:     http://mitpress.mit.edu/catalog/item/default.asp?ttype=2&tid=10916
// Gareth Loy's Musimathics website:    http://www.musimathics.com/
// The Musimat website:                 http://www.musimat.com/
// This program is released under the terms of the GNU General Public License
// available here:                      http://www.gnu.org/licenses/gpl.txt


#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include "Musimat.h"
#include <iostream>
#include <stdio.h>


class Rational
{
        friend ostream& operator<<(ostream&, Rational&);
        friend istream& operator>>( istream& is, Rational& p );

        friend Bool operator==(Integer& i, Rational& p) { Return i == p.quotient(); }
        friend Bool operator==(Rational& p, Integer& i) { Return p.quotient() == i; }
        friend Bool operator!=(Integer& i, Rational& p) { Return i != p.quotient(); }
        friend Bool operator!=(Rational& p, Integer& i) { Return p.quotient() != i; }
        friend Bool operator>=(Rational& p, Integer& r) { Return p.quotient() >= r; }
        friend Bool operator>=(Integer& i, Rational& p) { Return i >= p.quotient(); }
        friend Bool operator>(Rational& p, Integer& i) { Return p.quotient() > i; }
        friend Bool operator>(Integer& i, Rational& p) { Return i > p.quotient(); }
        friend Bool operator<=(Rational& p, Integer& i) { Return p.quotient() <= i; }
        friend Bool operator<=(Integer& i, Rational& p) { Return i <= p.quotient(); }

        friend Bool operator==(Real& r, Rational& p) { Return r == p.quotient(); }
        friend Bool operator==(Rational& p, Real& r) { Return p.quotient() == r; }
        friend Bool operator!=(Real& r, Rational& p) { Return r != p.quotient(); }
        friend Bool operator!=(Rational& p, Real& r){ Return p.quotient() != r; }
        friend Bool operator>=(Rational& p, Real& r) { Return p.quotient() >= r; }
        friend Bool operator>=(Real& r, Rational& p) { Return r >= p.quotient(); }
        friend Bool operator>(Rational& p, Real& r) { Return p.quotient() > r; }
        friend Bool operator>(Real& r, Rational& p) { Return r > p.quotient(); }
        friend Bool operator<=(Rational& p, Real& r) { Return p.quotient() <= r; }
        friend Bool operator<=(Real& r, Rational& p) { Return r <= p.quotient(); }

public:

        Rational() : m_num(0), m_den(0) { }

        Rational(Integer i) : m_num(i), m_den(i) { }

        Rational(Const Rational& x) : m_num(x.m_num), m_den(x.m_den) { }

        Rational(Real x) : m_num(0), m_den(0) { RealToRational( x, m_num, m_den ); }

        Rational(Integer num, Integer den) : m_num(num), m_den(den) {
                If (m_den == 0)
                        m_den = 1;
        }

        Rational(Real x, Integer& num, Integer& den) : m_num(0), m_den(0) { 
                RealToRational( x, num, den ); 
                m_num = num;
                m_den = den;
        }

        Rational(Rational x, Integer& num, Integer& den) : m_num(0), m_den(0) { 
                RealToRational( x.quotient(), num, den ); 
                m_num = num;
                m_den = den;
        }

        Rational& operator=(Const Rational& x) {
                m_num = x.m_num;
                m_den = x.m_den;
                Return *this;
        }

        Bool operator==(Const Rational& x) Const {
                Return m_num == x.m_num  And m_den == x.m_den;
        }

        Bool operator!=(Const Rational& x) Const {
                Return m_num != x.m_num || m_den != x.m_den;
        }

        Bool operator>=(Const Rational& x) Const {
                Return quotient() >= x.quotient();
        }

        Bool operator>(Const Rational& x) Const {
                Return quotient() > x.quotient();
        }

        Bool operator<(Const Rational& x) Const {
                Return quotient() < x.quotient();
        }

        Bool operator<=(Const Rational& x) Const {
                Return quotient() <= x.quotient();
        }

        Rational& operator+=(Const Real x) {
                Return( *this = Rational(quotient() + x) );
        }

        Rational& operator+=(Rational x) {
                Return( *this = Rational(quotient() + x.quotient() ) );
        }

        Rational& operator-=(Const Real x) {
                Return( *this = quotient() - x );
        }

        Rational& operator-=(Rational x) {
                Return( *this = quotient() - x.quotient() );
        }

        Rational& operator*=(Const Real x) {
                Return( *this = quotient() * x );
        }

        Rational& operator*=(Rational x) {
                Return( *this = quotient() * x.quotient() );
        }

        Rational& operator/=(Const Real x) {
                Return( *this = quotient() / x );
        }

        Rational& operator/=(Rational x) {
                Return( *this = quotient() / x.quotient() );
        }

        Rational operator+(Rational& x) {
                Return( Rational(quotient() + x.quotient()) );
        }

        Rational operator-(Rational& x) {
                Return( Rational(quotient() - x.quotient()) );
        }

        Rational operator*(Rational& x) {
                Return( Rational(quotient() * x.quotient()) );
        }

        Rational operator/(Rational& x) {
                Return( Rational(quotient() / x.quotient()) );
        }

        Rational operator+(Const Real x) {
                Return( Rational(quotient() + x) );
        }

        Rational operator-(Const Real x) {
                Return( Rational(quotient() - x) );
        }

        Rational operator*(Const Real x) {
                Return( Rational(quotient() * x) );
        }

        Rational operator/(Const Real x) {
                Return( Rational(quotient() / x ) );
        }

        String print(String s = 0) Const {
                If (s)
                        cout << s;
#ifdef _MSC_VER
// Disable Microsoft Visual Studio warning about sprintf()
// until is universal agreement about how to handle its insecurities
#pragma warning(push)
#pragma warning(disable: 4996)
                sprintf(s_buf, "{%d,%d}", m_num, m_den);
#pragma warning(pop)
#else
                sprintf(s_buf, "{%d,%d}", m_num, m_den);
#endif
                Return s_buf;
        }
        
private:
        // Absolute value of a Real
//      Real abs( Real x ) Const { Return x < 0 ? -x : x; }
        Real quotient() Const { Return( Real(m_num) / Real(m_den) ); }

protected:
        Integer m_num;
        Integer m_den;
        Static char s_buf[128];
};

#endif // Rational_H