fraction.cc

Go to the documentation of this file.

//
//  Copyright (c) 2006 by Rafael Ostertag
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
//
// $Id: fraction.cc,v 1.11 2006/12/31 00:49:39 rafi Exp $
//

#include <string>
#include <iostream>
#include <cstring>

#ifdef DEBUG
#include <cassert>
#endif

#include "casobject.h"
#include "casexception.h"
#include "fraction.h"
#include "longint.h"

// Private methods
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------


// Protected methods
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------


// Constructors & Destructor
// ----------------------------------------------------------------------------
Fraction::Fraction() {
#ifdef SHOWCONSTRUCTOR
    std::cerr << "# Fraction::Fraction()" << std::endl;
#endif

    LongInt tmp ( 1L );
    numerator = tmp.Clone();
    denominator = tmp.Clone();
}

Fraction::Fraction ( const CASObject* num, const CASObject* denom ) {
#ifdef SHOWCONSTRUCTOR
    std::cerr << "# Fraction::Fraction(const CASObject* num, const CASObject* denom)" << std::endl;
#endif

    checkptr ( num );
    checkptr ( denom );

    if ( denom->IsZero() ) {
        throw EDivByZero();
    }

    numerator = num->Clone();
    denominator = denom->Clone();
}

Fraction::Fraction ( const CASObject* denom ) {
#ifdef SHOWCONSTRUCTOR
    std::cerr << "# Fraction::Fraction(const CASObject* denom)" << std::endl;
#endif

    checkptr ( denom );

    if ( denom->IsZero() ) {
        throw EDivByZero();
    }

    LongInt t ( 1L );
    numerator = t.Clone();
    denominator = denominator->Clone();
}

Fraction::Fraction ( const Fraction &f ) {
#ifdef SHOWCONSTRUCTOR
    std::cerr << "# Fraction::Fraction(const Fraction &f)" << std::endl;
#endif

    numerator = f.numerator->Clone();
    denominator = f.denominator->Clone();
    meta = f.meta;
}

Fraction::~Fraction() {
#ifdef SHOWCONSTRUCTOR
    std::cerr << "# Fraction::~Fraction()" << std::endl;
#endif
#ifdef DEBUG
    assert ( numerator != 0 );
    assert ( denominator != 0 );
#endif
    delete numerator;
    delete denominator;
}
// ----------------------------------------------------------------------------


// Public Methods
// ----------------------------------------------------------------------------
CASObject*
Fraction::Clone() const {
    Fraction *ret_val = new Fraction;
#ifdef DEBUG
    assert ( ret_val->numerator != 0 );
    assert ( ret_val->denominator != 0 );
#endif

    CASObject::Garbage->Put ( ret_val->numerator );
    CASObject::Garbage->Put ( ret_val->denominator );

    ret_val->numerator = numerator->Clone();
    ret_val->denominator = denominator->Clone();

    ret_val->meta = meta;

    return ret_val;
}

void
Fraction::Get ( std::string &s ) const {
    if ( IsOne() ) {
        s = "1";
        return;
    }

    if ( IsZero() ) {
        s = "0";
        return;
    }

    s = "(";

    std::string tmp;
    numerator->Get ( tmp );
    s += tmp;

    s += "/";

    denominator->Get ( tmp );
    s += tmp;

    s += ")";

}

void
Fraction::Get ( char *s, unsigned long size ) const {
    checkptr ( s );

    if ( size < ( Length() + 1 ) ) {
        throw EBufTooSmall();
    }

    memset ( s, '\0', size );


    std::string tmp;
    Get ( tmp );

    strncpy ( s, tmp.c_str(), size );
}

void
Fraction::Print() const {
    std::string tmp;
    Get ( tmp );
    std::cout << tmp;
}

unsigned long
Fraction::Length() const {
    if ( IsZero() || IsOne() ) {
        return 1;
    }

    unsigned long len = 0;
    len += numerator->Length();
    len += denominator->Length();
    // Because the string representation puts the fraction in (X/X), we add 3,
    // one for '(', one for '/', and one for ')'
    len += 3;
    return len;
}

bool
Fraction::IsZero() const {
    return numerator->IsZero();
}

bool
Fraction::IsOne() const {
    return numerator->IsEqual ( denominator );
}

CASObject*
Fraction::Absolute() const {
    Fraction res;
    res = *this;
    res.numerator->AbsoluteIP();
    res.denominator->AbsoluteIP();

    return res.Clone();
}

void
Fraction::AbsoluteIP() {
    numerator->AbsoluteIP();
    denominator->AbsoluteIP();
}

CASObject*
Fraction::Invert() const {
#ifdef WARNINGS
#warning "Not Implemented: Fraction::Invert() const"
#endif
    throw ENotImplemented();
}

void
Fraction::InvertIP() {
#ifdef WARNINGS
#warning "Not Implemented: Fraction::InvertIP()"
#endif
    throw ENotImplemented();
}

CASObject*
Fraction::Add ( const CASObject* addend ) const {
    checkptr ( addend );

    // Prepare the resulting fraction
    Fraction *result = new Fraction;
    CASObject::Garbage->Put ( result->numerator );
    CASObject::Garbage->Put ( result->denominator );

    if ( GetType() == addend->GetType() ) {
        const Fraction *fr_ptr = dynamic_cast<const Fraction*> ( addend );
#ifdef DEBUG
        assert ( fr_ptr != 0 );
#endif

        result->denominator = denominator->Multiply ( fr_ptr->denominator );

        CASObject* num1 = numerator->Multiply ( fr_ptr->denominator );
        CASObject* num2 = fr_ptr->numerator->Multiply ( denominator );
        result->numerator = num1->Add ( num2 );

        CASObject::Garbage->Put ( num1 );
        CASObject::Garbage->Put ( num2 );

        return result;
    }

    CASObject* num = denominator->Multiply ( addend );
    result->numerator = numerator->Add ( num );
    result->denominator = denominator->Clone();

    return result;

}

CASObject*
Fraction::Subtract ( const CASObject* subtrahend ) const {
    checkptr ( subtrahend );

    // Prepare the resulting fraction
    Fraction *result = new Fraction;

    CASObject::Garbage->Put ( result->numerator );
    CASObject::Garbage->Put ( result->denominator );

    if ( GetType() == subtrahend->GetType() ) {
        const Fraction *fr_ptr = dynamic_cast<const Fraction*> ( subtrahend );
#ifdef DEBUG
        assert ( fr_ptr != 0 );
#endif

        result->denominator = denominator->Multiply ( fr_ptr->denominator );

        CASObject* num1 = numerator->Multiply ( fr_ptr->denominator );
        CASObject* num2 = fr_ptr->numerator->Multiply ( denominator );
        result->numerator = num1->Subtract ( num2 );

        CASObject::Garbage->Put ( num1 );
        CASObject::Garbage->Put ( num2 );

        return result;
    }

    CASObject* num = denominator->Multiply ( subtrahend );
    result->numerator = numerator->Subtract ( num );
    result->denominator = denominator->Clone();

    return result;
}

CASObject*
Fraction::Multiply ( const CASObject* factor ) const {
    checkptr ( factor );

    // Prepare the resulting fraction
    Fraction *result = new Fraction;

    CASObject::Garbage->Put ( result->numerator );
    CASObject::Garbage->Put ( result->denominator );

    if ( GetType() == factor->GetType() ) {
        const Fraction *fr_ptr = dynamic_cast<const Fraction*> ( factor );
#ifdef DEBUG

        assert ( fr_ptr != 0 );
#endif

        result->denominator = denominator->Multiply ( fr_ptr->denominator );
        result->numerator = numerator->Multiply ( fr_ptr->numerator );

        return result;
    }


    result->numerator = numerator->Multiply ( factor );
    result->denominator = denominator->Clone();

    return result;
}

CASObject*
Fraction::Divide ( const CASObject* divisor ) const {
    checkptr ( divisor );

    // Prepare the resulting fraction
    Fraction *result = new Fraction;

    CASObject::Garbage->Put ( result->numerator );
    CASObject::Garbage->Put ( result->denominator );

    if ( GetType() == divisor->GetType() ) {
        const Fraction *fr_ptr = dynamic_cast<const Fraction*> ( divisor );
#ifdef DEBUG

        assert ( fr_ptr != 0 );
#endif

        result->denominator = denominator->Multiply ( fr_ptr->numerator );
        result->numerator = numerator->Multiply ( fr_ptr->denominator );

        return result;
    }


    result->numerator = numerator->Clone();
    result->denominator = denominator->Multiply ( divisor );

    return result;

}

CASObject*
Fraction::Power ( const CASObject* exp ) const {
    checkptr ( exp );

    Fraction *result = new Fraction;

    CASObject::Garbage->Put ( result->numerator );
    CASObject::Garbage->Put ( result->denominator );

    result->numerator = numerator->Power ( exp );
    result->denominator = denominator->Power ( exp );

    return result;

}

CASObject*
Fraction::Modulo ( const CASObject* divisor ) const {
#ifdef WARNINGS
#warning "Not fully implemented: Fraction::Modulo(const CASObject*) const "
#endif
    LongInt *result = new LongInt ( 0L );
    return result;
}

CASObject*
Fraction::GCD ( const CASObject* o ) const {
#ifdef WARNINGS
#warning "Not fully implemented: Fraction::GCD(const CASObject*) const"
#endif
    LongInt *result = new LongInt ( 1L );
    return result;
}

bool
Fraction::IsEqual ( const CASObject* o ) const {
#ifdef WARNINGS
#warning "Not fully implemented: Fraction::IsEqual(const CASObject*) const"
#endif
    checkptr ( o );

    if ( GetType() == o->GetType() ) {
        const Fraction *fr_ptr = dynamic_cast<const Fraction*> ( o );
#ifdef DEBUG

        assert ( fr_ptr != 0 );
#endif

        return ( *this ) == ( *fr_ptr );
    }
    else {
        return false;
    }
}

bool
Fraction::IsLT ( const CASObject* o ) const {
    checkptr ( o );

    if ( GetType() < o->GetType() ) {
        return true;
    }

    if ( GetType() > o->GetType() ) {
        return false;
    }

    const Fraction *f = dynamic_cast<const Fraction*> ( o );
#ifdef DEBUG
    assert ( o != 0 );
#endif

    if ( denominator->IsLT ( f->denominator ) ) {
        return false;
    }

    if ( denominator->IsGT ( f->denominator ) ) {
        return true;
    }

    return numerator->IsLT ( f->numerator );
}

bool
Fraction::IsGT ( const CASObject* o ) const {
    checkptr ( o );
    if ( IsEqual ( o ) ) {
        return false;
    }

    return !IsLT ( o );
}

bool
Fraction::IsSimilar ( const CASObject *o ) const {
    checkptr ( o );

    if ( GetType() != o->GetType() ) {
        return false;
    }

    const Fraction *fr = dynamic_cast<const Fraction*> ( o );
#ifdef DEBUG
    assert ( fr != 0 );
#endif

    return ( fr->numerator->IsSimilar ( numerator ) &&
             fr->denominator->IsSimilar ( denominator ) );
}

CASObject*
Fraction::SortWeight() const {
    CASObject* weightnumerator = numerator->SortWeight();
    CASObject* weightdenominator = denominator->SortWeight();
    CASObject* weight = weightnumerator->Divide ( weightdenominator );
    CASObject::Garbage->Put ( weightnumerator );
    CASObject::Garbage->Put ( weightdenominator );

    return weight;
}

void
Fraction::Sort()  {
    if ( meta.IsSorted() ) {
        return;
    }
    checkptr ( numerator );
    checkptr ( denominator );
    numerator->Sort();
    denominator->Sort();
    meta.SetSorted();
}

CASObject*
Fraction::Evaluate() const {
    if ( meta.IsEvaluated() ) {
        return Clone();
    }
    Fraction *ret_val = dynamic_cast<Fraction*> ( Clone() );
#ifdef DEBUG

    assert ( ret_val != 0 );
#endif

    CASObject* denom = ret_val->denominator;
    CASObject* num = ret_val->numerator;

    ret_val->denominator = ret_val->denominator->Evaluate();
    ret_val->numerator = ret_val->numerator->Evaluate();

    CASObject::Garbage->Put ( denom );
    CASObject::Garbage->Put ( num );

    ret_val->meta.SetEvaluated();
    ret_val->Sort();

    return ret_val;
}

inline bool Fraction::IsPureNumerical() const {
    return numerator->IsPureNumerical() && denominator->IsPureNumerical();
}

// ----------------------------------------------------------------------------

// Operators
// ----------------------------------------------------------------------------
const Fraction&
Fraction::operator= ( const Fraction &f ) {
#ifdef SHOWCONSTRUCTOR
    std::cerr << "# Fraction::operator=(const Fraction &f)" << std::endl;
#endif

    if ( this == &f ) {
        return *this;
    }

#ifdef DEBUG
    assert ( numerator != 0 );
    assert ( denominator != 0 );
#endif

    CASObject::Garbage->Put ( numerator );
    CASObject::Garbage->Put ( denominator );

    numerator = f.numerator->Clone();
    denominator = f.denominator->Clone();
    meta = f.meta;

    return *this;
}

const bool
Fraction::operator== ( const Fraction &f ) const {
#ifdef WARNINGS
#warning "Not fully implemented: Fraction::operator==(const Fraction &f)"
#endif
#ifdef DEBUG
    assert ( numerator != 0 );
    assert ( denominator != 0 );
#endif

    return numerator->IsEqual ( f.numerator ) && denominator->IsEqual ( f.denominator );
}
// ----------------------------------------------------------------------------

---