MFraction.cpp

Go to the documentation of this file.

#include "MFraction.h"

#ifndef FRACTION_ONLY   

        #include <string>       

        /**************** INITIALIZES DEFAULT MFRACTION FORMAT BEHAVIOUR ****************/

        MFraction::FracFormat MFraction::FORMAT = MIX_FRAC;

        /******************* DEFINES FORMAT ACCESSOR/MUTATOR METHODS *******************/

        //this method sets the fraction format (how the fraction is to be outputed)
        void MFraction::setFormat(const MFraction::FracFormat &format)
        {
                FORMAT = format;
        }

        //this method returns the fraction format (how the fraction is being outputed)
        MFraction::FracFormat MFraction::getFormat()
        {
                return (FORMAT);
        }

        /*********************** HELPER METHODS PRIVATE TO CLASS ***********************/

        //reduces the improper version of the fraction created by Fraction class's reduce() method into a mixed fraction
        void MFraction::reduce()
        {
                //Fraction class's reduce() method is called already when Fraction constructor is called
                //or when Fraction's classes operations (+,- etc.) are called.
                if (numerator >= denominator)
                {
                        whole += numerator/denominator;
                        numerator %= denominator;
                }
        }

        /*************************** CONSTRUCTORS/DESTRUCTORS **************************/

        //default constructor: sets fraction to 0
        MFraction::MFraction() : Fraction()
        {
                whole = 0;
        }

        //constructor converts a decimal number into a fraction
        //accuracy roughly around 3-4 decimal places
        MFraction::MFraction(const double &number) : Fraction(number)
        {              //Fraction class's reduce() method runs before code below executes
                whole = 0;
                reduce();  //convert fraction into reduced mixed representation by calling MFraction's reduce()
        }

        //takes numerator and denominator of fraction (not reduced) and creates a reduced mixed fraction
        MFraction::MFraction(const int &numerator, const int &denominator) : Fraction(numerator,denominator)
        {
                whole = 0;
                reduce();
        }

        //takes whole, numerator and denominator of fraction (not reduced) and creates a reduced mixed fraction
        MFraction::MFraction(const int &whole, const int &numerator, const int &denominator) : Fraction(numerator,denominator)
        {
                if (whole < 0) sign = !sign;
                this->whole = abs(whole);
                reduce();
        }

        //converts a valid character array into a fraction
        MFraction::MFraction(const char *frac)
        {
                //convert the character array into a string
                string fraction = frac;

                //if the string parameter has any characters other than "-0123456789./", it is invalid
                if (fraction.find_first_not_of("-0123456789./")!=-1)
                        throw (FR_STR_INVALID);

                //find position of the decimal place, if present
                int pos = fraction.find_first_of(".");

                if (pos!=-1)                                       //if a decimal place is present
                {   //check that all other characters are numbers only
                        if (fraction.find_first_of("/")==-1 && fraction.find_first_of(".",pos+1)==-1)
                                *this = MFraction(atof(fraction.c_str())); //if so, create a MFraction object
                        else
                                throw (FR_STR_INVALID);                       //otherwise, string is invalid
                }
                else
                {
                        pos = fraction.find_first_of("/");               //if there was no decimal place, look for a slash

                        if (pos==-1)                                     //if there is no / at all, ie. "5"
                                *this = MFraction(atoi(fraction.c_str()));
                        else                                              //if one slash was found
                        {
                                int pos2 = fraction.find_first_of("/",pos+1); //look for a second slash

                                if (pos2==-1)                                 //if there is no second slash
                                        *this = MFraction(atoi(fraction.substr(0,pos).c_str()),atoi(fraction.substr(pos+1,fraction.length()-pos-1).c_str()));
                                else if (fraction.find_first_of("/",pos2+1)==-1)  //if there is no third slash, but there is a 2nd one
                                        *this = MFraction(atoi(fraction.substr(0,pos).c_str()),atoi(fraction.substr(pos+1,pos2-pos-1).c_str()),atoi(fraction.substr(pos2+1,fraction.length()-pos2-1).c_str()));
                                else
                                        throw (FR_STR_INVALID);                       //otherwise, string is invalid
                        }
                }
        }

        //copy constructor: copies another fraction (of type Fraction) into the created fraction
        MFraction::MFraction(const Fraction &frac) : Fraction(frac)
        {
                whole = 0;
                reduce();
        }

        //copy constructor: copies another fraction (of type MFraction) into the created fraction
        MFraction::MFraction(const MFraction &frac) : Fraction(frac)
        {
                whole = frac.whole;
        }

        //destructor: does nothing as there are no dynamic memory
        //the data members are deallocated automatically
        MFraction::~MFraction()  //destructor for Fraction is called auto after this
        {
        }

        /******************************* MUTATOR METHODS *******************************/

        //sets the whole number portion of the fraction
        void MFraction::setWhole(int whole)
        {               
                sign = whole >= 0;
                this->whole = abs(whole);
        }
        
        //sets the numerator of the fraction
        void MFraction::setNum(int numerator)
        {
                Fraction::setNum(numerator);
                reduce();
        }

        //sets the denominator of the fraction
        void MFraction::setDen(int denominator)
        {
                Fraction::setDen(denominator);
                reduce();
        }

        /**************************** OVERLOADED OPERATORS *****************************/

        //the subscript operator must be a member function
        //pass in 0 to get whole (signed), 1 for numerator (signed), 2 for denominator (unsigned)
        int MFraction::operator [] (const unsigned int &subscript) const
        {
                if (subscript > 2) throw (FR_INDEX_OUT_BOUNDS);

                if (subscript == 0)
                {
                        if (sign) return (whole);
                        else return (-static_cast<int>(whole));
                }
                else return (Fraction::operator [] (subscript - 1));
        }

        //calling object is made equal to object on the right of operator
        MFraction& MFraction::operator = (const MFraction &right)
        {
                Fraction::operator = (right);   
                if (this != &right) whole = right.whole;
                return (*this); //so tht x = y = z is possible; (x = y) returns a reference which gets equated to z
        }

        //negation operator: returns the negated value of fraction, but doesnt change original
        MFraction MFraction::operator - () const
        {
                if (sign) return (MFraction(-static_cast<int>(whole),numerator,denominator));
                else return (MFraction(whole,numerator,denominator));
        }

        //prefix increment operator: adds 1 to fraction
        MFraction MFraction::operator ++ ()
        {
                return (MFraction::operator ++ (1));
        }

        //prefix decrement operator: subtracts 1 from fraction
        MFraction MFraction::operator -- ()
        {
                return (MFraction::operator -- (1));
        }

        //postfix increment operator: increments fraction by inc; if inc is 0, increments by 1
        MFraction MFraction::operator ++ (int inc)
        {
                if (inc < 0) throw (FR_NEG_PARAM);

                if (inc == 0) inc = 1;

                if (sign) whole += inc;
                else if (whole > inc) whole-= inc;
                else
                {
                        sign = !sign;
                        whole = inc - whole;
                }
                
                return (*this);
        }

        //postfix decrement operator: decrements fraction by dec; if dec is 0, decrements by 1
        MFraction MFraction::operator -- (int dec)
        {
                if (dec < 0) throw (FR_NEG_PARAM);

                if (dec == 0) dec = 1;

                if (!sign) whole += dec;
                else if (whole >= dec) whole -= dec;
                else
                {
                        sign = !sign;
                        whole = dec - whole;
                }

                return (*this);
        }

        //defines the addition/assignment operator
        //adds fraction to the right of the operator to Fraction object on the left and returns this object
        MFraction MFraction::operator += (const MFraction &right)
        {
                *this = *this + right;
                return (*this);
        }

        //defines the subtraction/assignment operator
        //subtracts fraction to the right of the operator to Fraction object on the left and returns this object
        MFraction MFraction::operator -= (const MFraction &right)
        {
                *this = *this - right;
                return (*this);
        }

        //defines the multiplication/assignment operator
        //calling object is multiplied by fraction on the right of the operator and the result is assigned to the calling object
        MFraction MFraction::operator *= (const MFraction &right)
        {
                *this = *this * right;
                return (*this);
        }

        //defines the division/assignment operator
        //calling object is divided by fraction on the right of the operator and the result is assigned to the calling object
        MFraction MFraction::operator /= (const MFraction &right)
        {
                *this = *this / right;
                return (*this);
        }

        /************************ FRIENDS OVERLOADED OPERATORS *************************/

        //returns true if 2 fractions are the same
        bool operator == (const MFraction &left, const MFraction &right)
        {
                return (left.whole==right.whole && left.sign==right.sign && left.numerator==right.numerator && left.denominator==right.denominator);
        }

        //returns true if 2 fractions are not the same
        bool operator != (const MFraction &left, const MFraction &right)
        {
                return (left.whole!=right.whole || left.sign!=right.sign || left.numerator!=right.numerator || left.denominator!=right.denominator);
        }

        //returns true if left fraction is less than the fraction on the right of the operator
        bool operator < (const MFraction &left, const MFraction &right)
        {
                int left_numerator = (left[0]*left.denominator + left[1]) * right.denominator;
                int right_numerator = (right[0]*right.denominator + right[1]) * left.denominator;
                return (left_numerator < right_numerator);      
        }

        //returns true if left fraction is less than or equal to the fraction on the right of the operator
        bool operator <= (const MFraction &left, const MFraction &right)
        {
                return (left<right || left==right);
        }

        //returns true if left fraction is greater than the fraction on the right of the operator
        bool operator > (const MFraction &left, const MFraction &right)
        {
                return (!(left <= right));
        }

        //returns true if left fraction is greater than or euqal to the fraction on the right of the operator
        bool operator >= (const MFraction &left, const MFraction &right)
        {
                return (!(left < right));
        }

        //adds 2 fractions on either side of the operator and returns the result
        MFraction operator + (const MFraction &left, const MFraction &right)
        {
                return (MFraction(0, (left[0]*left.denominator+left[1])*right.denominator+(right[0]*right.denominator+right[1])*left.denominator, left.denominator*right.denominator));
        }

        //subtracts 2 fractions on either side of the operator and returns the result
        MFraction operator - (const MFraction &left, const MFraction &right)
        {
                return (MFraction(0, (left[0]*left.denominator+left[1])*right.denominator-(right[0]*right.denominator+right[1])*left.denominator, left.denominator*right.denominator));
        }

        //multiplies 2 fractions on either side of the operator and returns the result
        MFraction operator * (const MFraction &left, const MFraction &right)
        {
                return (MFraction(0, (left[0]*left.denominator+left[1])*(right[0]*right.denominator+right[1]), left.denominator*right.denominator));
        }

        //divides 2 fractions on either side of the operator and returns the result
        MFraction operator / (const MFraction &left, const MFraction &right)
        {
                return (MFraction(0, (left[0]*left.denominator+left[1])*right.denominator, left.denominator*(right[0]*right.denominator+right[1])));
        }

        /**************************** STREAM INPUT/OUTPUT ******************************/

        //stream output
        ostream &operator << (ostream &out, const MFraction &fraction)
        {
                if (!fraction.sign) out << "-";

                if (MFraction::FORMAT == MFraction::DECI)
                        out << fraction.whole + static_cast<double>(fraction.numerator)/static_cast<double>(fraction.denominator);
                else
                {
                        if (MFraction::FORMAT==MFraction::MIX_FRAC)
                        {
                                if (fraction.whole != 0) out << fraction.whole;
                                if (fraction.whole != 0 && fraction.numerator != 0) out << "/";  //dont get 5/0 or /0
                                if (!(fraction.whole != 0 && fraction.numerator == 0)) out << fraction.numerator;
                        }
                        else out << (fraction.whole * fraction.denominator) + fraction.numerator; //if type is of IM_FRAC
                        if (fraction.denominator != 1) out << "/" << fraction.denominator;
                }

                return (out);
        }

        //stream input
        istream &operator >> (istream &in, MFraction &fraction)
        {
                string input;
                in >> input;
                fraction = input.c_str();

                return (in);
        }
#endif