variable.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: variable.cc,v 1.14 2006/12/31 00:49:39 rafi Exp $
//

#include <string>
#include <iostream>

#ifdef DEBUG
#include <cassert>
#endif

#include "sum.h"
#include "product.h"
#include "variable.h"
#include "longint.h"
#include "fraction.h"

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

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

// Constructors & Destructor
// ----------------------------------------------------------------------------
Variable::Variable() : name ( "a" ) {
#ifdef SHOWCONSTRUCTOR
    std::cerr << "# Variable::Variable()" << std::endl;
#endif
    exponent = new LongInt ( 1L );
    meta.SetSingleValue();
}

Variable::Variable ( const std::string n, const CASObject* exp ) : name ( n ) {
#ifdef SHOWCONSTRUCTOR
    std::cerr << "# Variable::Variable(const std::string n, const CASObject* exponent)" << std::endl;
#endif
    checkptr ( exp );

    exponent = exp->Clone();
    meta.SetSingleValue();
}

Variable::Variable ( const std::string n ) : name ( n ) {
#ifdef SHOWCONSTRUCTOR
    std::cerr << "# Variable::Variable(const std::string n)" << std::endl;
#endif
    exponent = new LongInt ( 1L );
    meta.SetSingleValue();
}

Variable::Variable ( const Variable &v ) {
#ifdef SHOWCONSTRUCTOR
    std::cerr << "# Variable::Variable(const Variable &v)" << std::endl;
#endif
    name = v.name;
    exponent = v.exponent->Clone();
    meta = v.meta;
}

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


// Public Methods
// ----------------------------------------------------------------------------
CASObject*
Variable::Clone() const{
    Variable *tmp = new Variable;

    *tmp = *this;

    return tmp;
}

void
Variable::Get ( std::string &s ) const{
    if ( exponent->IsZero() ) {
        s = "1";
        return;
    }

    if ( exponent->IsOne() ) {
        s = name;
    } else {
        s = name;
        if ( exponent->meta.IsSingleValue() ) {
            s += "^";
        } else {
            s += "^(";
        }

        std::string tmp;
        exponent->Get ( tmp );

        s += tmp;
        if ( !exponent->meta.IsSingleValue() ) {
            s += ")";
        }
    }
}

void
Variable::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
Variable::Print() const{
    std::string tmp;
    Get ( tmp );
    std::cout << tmp;
}

unsigned long
Variable::Length() const {
    if ( exponent->IsOne() || exponent->IsZero() ) {
        return 1;
    }

    unsigned long len = 0;
    len += name.size();
    len += exponent->Length();
    // Add 3 for '^()'
    len += 3;

    return len;
}

bool
Variable::IsZero() const{
    return false;
}

bool
Variable::IsOne() const{
    return exponent->IsZero();
}

CASObject*
Variable::Absolute() const{
    return Clone();
}

void
Variable::AbsoluteIP() {
    // Intentionally left blank.
}

CASObject*
Variable::Invert() const{
    Product *res = new Product;
    LongInt mo ( -1L );
    mo.meta.SetCoefficient();

    res->Append ( &mo );
    res->Append ( this );
    return res;
}

void
Variable::InvertIP() {
    // Intentionally left blank.
}

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

    if ( GetType() == addend->GetType() ) {
        if ( IsEqual ( addend ) ) {
            LongInt coeff ( 2L );
            Product* res = new Product;
            res->Append ( &coeff );
            res->Append ( addend );
            return res;
        }
    }

    Sum *result = new Sum;
    result->Append ( this );
    result->Append ( addend );

    return result;
}

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

    if ( GetType() == subtrahend->GetType() ) {
        if ( IsEqual ( subtrahend ) ) {
            return new LongInt ( 0L );
        }

        Sum *res = new Sum;
        CASObject *inv_subtrahend = subtrahend->Invert();

        res->Append ( this );
        res->Append ( inv_subtrahend );
        return res;
    }

    Sum tmp;
    CASObject *result;

    tmp.Append ( this );
    result = tmp.Subtract ( subtrahend );

    return result;
}

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

    if ( GetType() == factor->GetType() ) {
        const Variable *var_ptr = dynamic_cast<const Variable*> ( factor );
#ifdef DEBUG
        assert ( var_ptr != 0 );
#endif
        if ( name == var_ptr->name ) {
            Variable *result = new Variable;
            CASObject::Garbage->Put ( result->exponent );
            result->name = name;
            result->exponent = exponent->Add ( var_ptr->exponent );

            return result;
        }
    }

    Product *result = new Product;
    result->Append ( this );

    // Check if the factor is a Coefficient
    CASObject *tmp = factor->Clone();
    if ( tmp->IsPureNumerical() ) {
        tmp->meta.SetCoefficient();
    }
    result->Append ( tmp );
    CASObject::Garbage->Put ( tmp );

    return result;
}

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

    if ( GetType() == divisor->GetType() ) {
        const Variable *var_ptr = dynamic_cast<const Variable*> ( divisor );
#ifdef DEBUG
        assert ( var_ptr != 0 );
#endif
        if ( name == var_ptr->name ) {
            Variable *result = new Variable;
            CASObject::Garbage->Put ( result->exponent );
            result->name = name;
            result->exponent = exponent->Subtract ( var_ptr->exponent );

            return result;
        }
    }

    Fraction *result = new Fraction ( this, divisor );

    return result;

}

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

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

    Variable* result = dynamic_cast<Variable*> ( Clone() );
#ifdef DEBUG
    assert ( result != 0 );
#endif
    CASObject *new_exp = result->exponent->Multiply ( exp );
    CASObject::Garbage->Put ( result->exponent );
    result->exponent = new_exp;

    return result;
}

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

bool
Variable::IsEqual ( const CASObject* o ) const {
    checkptr ( o );
    if ( GetType() != o->GetType() ) {
        return false;
    }
    const Variable *var_ptr = dynamic_cast<const Variable*> ( o );
#ifdef DEBUG
    assert ( var_ptr != 0 );
#endif

    if ( name == var_ptr->name &&
            exponent->IsEqual ( var_ptr->exponent ) ) {
        return true;
    }

    return false;
}

bool
Variable::IsLT ( const CASObject* o ) const {
#ifdef WARNINGS
#warning "Not fully implemented: bool Variable::IsLT(const CASObject* o) const"
#endif

    checkptr ( o );

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

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

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

    if ( name < v->name ) {
        return true;
    }

    if ( name > v->name ) {
        return false;
    }

    return exponent->IsLT ( v->exponent );
}
bool
Variable::IsGT ( const CASObject* o ) const {
#ifdef WARNINGS
#warning "Not fully implemented: bool Variable::IsGT(const CASObject* o) const"
#endif
    checkptr ( o );

    if ( IsEqual ( o ) ) {
        return false;
    }

    return !IsLT ( o );
}

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

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

    const Variable* var = dynamic_cast<const Variable*> ( o );
#ifdef DEBUG
    assert ( var != 0 );
#endif
    if ( var->name == name ) {
        return true;
    }

    return false;
}

CASObject*
Variable::SortWeight() const {
    LongInt weight ( 0L );
    for ( unsigned long i = 0;i < name.length();i++ ) {
        weight = weight + name[i];
    }
    return weight.Clone();
}

void
Variable::Sort() {
    if ( meta.IsSorted() ) {
        return;
    }
    exponent->Sort();
    meta.SetSorted();
}

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

    CASObject *exp = ret_val->exponent;
    ret_val->exponent = ret_val->exponent->Evaluate();

    CASObject::Garbage->Put ( exp );

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

    return ret_val;
}

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

// Operators
// ----------------------------------------------------------------------------
const Variable&
Variable::operator= ( const Variable &v ) {
#ifdef SHOWCONSTRUCTOR
    std::cerr << "# Variable::operator=(const Variable &v)" << std::endl;
#endif
    if ( &v == this ) {
        return *this;
    }

#ifdef DEBUG
    assert ( exponent != 0 );
#endif
    name = v.name;

    CASObject::Garbage->Put ( exponent );
    exponent = v.exponent->Clone();

    meta = v.meta;

    return *this;
}

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

---