C / C++ / MFC

Rational::Rational( int Num , int Den )
{
   int A = Num;
   int B = Den;

   int temp;

   while(B)
   {
      temp = B;
      B = A%B;
      A = temp;
   }

   if( A != 0 )
   {
      Numerator_ = Num/A;
      Denominator_ = Den/A;
   }
}

#ifndef RATIONAL_
#define RATIONAL_

using namespace std;

#include <iostream>

class Rational
{
  public:

    // Construct rational from numerator and denominator
    //
    Rational( int = 0, int = 1 );

    // Construct rational by copying existing rational
    //
    Rational( const Rational& );

    // Assign into rational by copying existing rational
    //
    Rational& operator=( const Rational& );

         //Find Greatest Common Divisor
         int GCD();

         //Simplify the rational number to its smallest form
         void Simplify();

    // Return true if rational is valid (non-zero denominator)
    //
    bool IsValid() const;

    // Return value of numerator
    //
    int Numerator() const;

    // Return value of denominator
    //
    int Denominator() const;

    // Input/Output operations
    //
    friend istream& operator>>( istream&, Rational& );
    friend ostream& operator<<( ostream&, const Rational& );

  private:

    // Insert your declarations here
         int Numerator_;
         int Denominator_;
};

// Comparative operations
//
bool operator==( const Rational&, const Rational& );
bool operator!=( const Rational&, const Rational& );
bool operator< ( const Rational&, const Rational& );
bool operator<=( const Rational&, const Rational& );
bool operator> ( const Rational&, const Rational& );
bool operator>=( const Rational&, const Rational& );

// Arithmetic operations
//
Rational operator+( const Rational&, const Rational& );
Rational operator-( const Rational&, const Rational& );
Rational operator*( const Rational&, const Rational& );
Rational operator/( const Rational&, const Rational& );

#endif
</iostream>

using namespace std;

#include <iostream>

#include "proj06.rational.h"


/*-----------------------------------------------------------------------------
   Name:  constructor for class "Rational"

   Purpose:  Initialize the contents of a rational number
   Receive:  The numerator and denominator or rational number
-----------------------------------------------------------------------------*/

Rational::Rational( int Num, int Den )
{
   Numerator_ = Num;

  if (Den <= 0)
  {
    Denominator_ = 1;
  }
  else
  {
    Denominator_ = Den;
  }
}

/*-----------------------------------------------------------------------------
   Name:  copy constructor for class "Rational"

   Purpose:  Initialize the value and scale inside a Rational object
   Recieve:   The rational to be copied
-----------------------------------------------------------------------------*/

Rational::Rational( const Rational& C )
{
  Numerator_ = C.Numerator_;
  Denominator_ = C.Denominator_;
}

/*-----------------------------------------------------------------------------
   Name:  assignment operator for class "Rational"

   Purpose:  Copy the contents of one rational to another
        Recieve:         The rational which is to be copied
   Return:   The rational number
-----------------------------------------------------------------------------*/

Rational& Rational::operator=(const Rational& C )
{
        Numerator_ = C.Numerator_;
        Denominator_ = C.Denominator_;

        return *this;
}
 
/*-----------------------------------------------------------------------------
   Name: GCD 
 
   Purpose:  Find the greatest common divisor of a rational number
   Return:   GCD
-----------------------------------------------------------------------------*/
 
int Rational::GCD()
{
        int A = Numerator_;
        int B = Denominator_;

        int Temp;

        while(B)
        {
                Temp = B;
                B = A%B;
                A = Temp;
        }

        return A;
}

/*-----------------------------------------------------------------------------
   Name:        Simplify
 
   Purpose:  Simplify a rational number
-----------------------------------------------------------------------------*/
 
void Rational::Simplify()
{
        int GCDNumber = GCD();

        if(GCDNumber != 0)
        {
                Numerator_ = Numerator_/GCDNumber;
                Denominator_ = Denominator_/GCDNumber;
        }
}

/*-----------------------------------------------------------------------------
   Name:  IsValid
 
   Purpose:  Test whether or not the rational is valid
   Return:   The Boolean value for the result of the test
-----------------------------------------------------------------------------*/
 
bool Rational::IsValid() const
{
  return ( Denominator_ != 0 ); 
}

/*-----------------------------------------------------------------------------
   Name:  Numerator
 
   Purpose:  extract numerator from rational number
        Return:  numerator
-----------------------------------------------------------------------------*/

int Rational::Numerator() const
{
        return Numerator_;
}

/*-----------------------------------------------------------------------------
   Name:  Denominator
 
   Purpose:  extract denominator from rational number
        Return:          denominator
-----------------------------------------------------------------------------*/

int Rational::Denominator() const
{
        return Denominator_;
}

/*-----------------------------------------------------------------------------
   Name:  operator==
 
   Purpose:  compare 2 rationals for equality
        Recieve:         the 2 rationals
        Return:  boolean result of the comparison
-----------------------------------------------------------------------------*/

bool operator==( const Rational& A, const Rational& B ) 
{
        A.Simplify();
        B.Simplify();

        return(A.Numerator() == B.Numerator() and A.Denominator()== B.Denominator());
}
 

/*-----------------------------------------------------------------------------
   Name:  operator!=
 
   Purpose:  compare 2 rationals for inequality
        Recieve:         the 2 rationals
        Return:  boolean result of the comparison
-----------------------------------------------------------------------------*/

bool operator!=( const Rational& A, const Rational& B ) 
{
        A.Simplify();
        B.Simplify();

        return(A.Numerator() != B.Numerator() and A.Denominator()!= B.Denominator());
}

/*-----------------------------------------------------------------------------
   Name:  operator<<br mode="hold" /> 
   Purpose:  tell whether A is less than B
        Recieve:         the 2 rationals A and B
        Return:  boolean result of the comparison
-----------------------------------------------------------------------------*/

bool operator<( const Rational& A, const Rational& B ) 
{
        A.Simplify();
        B.Simplify();

        return(A.Numerator()*B.Denominator())<(A.Denominator()*B.Numerator());
}

/*-----------------------------------------------------------------------------
   Name:  operator<=
 
   Purpose:  tell whether A is less than or equal to B
        Recieve:         the 2 rationals A and B
        Return:  boolean result of the comparison
-----------------------------------------------------------------------------*/

bool operator<=( const Rational& A, const Rational& B ) 
{
        A.Simplify();
        B.Simplify();

        return(A.Numerator()*B.Denominator())<=(A.Denominator()*B.Numerator());
}


/*-----------------------------------------------------------------------------
   Name:  operator>
 
   Purpose:  tell whether A is greater than B
        Recieve:         the 2 rationals A and B
        Return:  boolean result of the comparison
-----------------------------------------------------------------------------*/

bool operator>( const Rational& A, const Rational& B ) 
{
        A.Simplify();
        B.Simplify();

        return(A.Numerator()*B.Denominator())>(A.Denominator()*B.Numerator());
}

/*-----------------------------------------------------------------------------
   Name:  operator>=
 
   Purpose:  tell whether A is greater than or equal to B
        Recieve:         the 2 rationals A and B
        Return:  boolean result of the comparison
-----------------------------------------------------------------------------*/

bool operator>=( const Rational& A, const Rational& B ) 
{
        A.Simplify();
        B.Simplify();

        return(A.Numerator()*B.Denominator())>=(A.Denominator()*B.Numerator());
}

/*-----------------------------------------------------------------------------
   Name:  operator+
 
   Purpose:  Add two rational numbers
        Recieve:         The two rationals to be added
        Return:  The rational result of adding the two rationals
-----------------------------------------------------------------------------*/

Rational operator+( const Rational& A, const Rational B ) 
{
        int Num;
        int Den;

        Num = A.Numerator()*B.Denominator()+A.Denominator()*B.Numerator();
        Den = A.Denominator()*B.Denominator();

        Rational C(Num, Den);
        return C.Simplify();
}


/*-----------------------------------------------------------------------------
   Name:  operator-
 
   Purpose:  Subtract two rational numbers
        Recieve:         The two rationals to be subtracted
        Return:  The rational result of subtracting the two rationals
-----------------------------------------------------------------------------*/

Rational operator-( const Rational& A, const Rational B ) 
{
        int Num;
        int Den;

        Num = A.Numerator()*B.Denominator()-A.Denominator()*B.Numerator();
        Den = A.Denominator()*B.Denominator();

        Rational C(Num, Den);
        return C.Simplify();
}

/*-----------------------------------------------------------------------------
   Name:  operator*
 
   Purpose:  Multiply two rational numbers
        Recieve:         The two rationals to be multiplied
        Return:  The rational result of multiplying the two rationals
-----------------------------------------------------------------------------*/

Rational operator*( const Rational& A, const Rational B ) 
{
        int Num;
        int Den;

        Num = A.Numerator()*B.Numerator();
        Den = A.Denominator()*B.Denominator();

        Rational C(Num, Den);
        return C.Simplify();
}

/*-----------------------------------------------------------------------------
   Name:  operator/
 
   Purpose:  Divide two rational numbers
        Recieve:         The two rationals to be divided
        Return:  The rational result of dividing the two rationals
-----------------------------------------------------------------------------*/

Rational operator/( const Rational& A, const Rational B ) 
{
        int Num;
        int Den;

        Num = A.Numerator()*B.Denominator();
        Den = A.Denominator()*B.Numerator();

        Rational C(Num, Den);
        return C.Simplify();
}


/*-----------------------------------------------------------------------------
   Name:  operator<<

   Purpose:  Put a rational into an output stream
   Receive:  The reference to an output stream
             The refernce to a rational which is to be written
   Return:   The output stream (for chaining)
        Ouput:   A rational number "numerator/denominator"
-----------------------------------------------------------------------------*/

ostream& operator<<( ostream& Out, const Rational& Item ) 
{
        Out << Item.Numerator() << "/" << Item.Denominator();

        return Out;
}


/*-----------------------------------------------------------------------------
   Name:  operator>>

   Purpose:  extract a rational from an input stream
   Receive:  The reference to aninput stream
             The reference to a rational which is to be written
   Return:   The input stream (for chaining)
        Input:   a rational number
-----------------------------------------------------------------------------*/</iostream>