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

#ifdef DEBUG
#include <cassert>
#endif
#include <vector>
#include <algorithm>

#include "casterm.h"
#ifndef _CASFUNCOBJ_H
#include "casfuncobj.h"
#endif
#include "casexception.h"
#include "longint.h"

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

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


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

void
CASTerm::GetNonSingleValues ( std::vector<const CASObject*> &lst ) const {
    CASExtractNonSingleValues nsv;
    nsv = std::for_each ( operands.begin(), operands.end(), nsv );
    nsv.Result ( lst );
}

void
CASTerm::GetSingleValues ( std::vector<const CASObject*> &lst ) const {
    CASExtractSingleValues sv;
    sv = std::for_each ( operands.begin(), operands.end(), sv );
    sv.Result ( lst );
}

bool
CASTerm::HaveSameOperands ( const CASObject *o ) const {
    checkptr ( o );

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

    CASTerm *this_term = dynamic_cast<CASTerm*> ( Clone() );
    CASTerm *that_term = dynamic_cast<CASTerm*> ( o->Clone() );
#ifdef DEBUG
    assert ( this_term != 0 );
    assert ( that_term != 0 );
#endif

    if ( operands.size() != that_term->operands.size() ) {
        return false;
    }

    this_term->Sort();
    that_term->Sort();

    bool ret_val = std::equal ( this_term->operands.begin(),
                                this_term->operands.end(),
                                that_term->operands.begin(),
                                CASObjectEqual() );

    CASObject::Garbage->Put ( this_term );
    CASObject::Garbage->Put ( that_term );

    return ret_val;
}

void
CASTerm::GetOperands ( const CASTerm *t, std::vector<const CASObject*> &out ) const {
    std::copy ( t->operands.begin(),
                t->operands.end(),
                std::back_inserter ( out ) );
}

void
CASTerm::SetOperands ( CASTerm *t, const std::vector<const CASObject*> &in ) const{
    if ( t->operands.size() != 0 ) {
        CASObject::Garbage->Put ( t->operands );
        t->operands.clear();
    }

    std::transform ( in.begin(),
                     in.end(),
                     std::back_inserter ( t->operands ),
                     CASCloneObject()
                   );
}

void
CASTerm::SetOperands ( CASTerm *t, const std::vector<CASObject*> &in ) const{
    if ( t->operands.size() != 0 ) {
        CASObject::Garbage->Put ( t->operands );
        t->operands.clear();
    }

    std::transform ( in.begin(),
                     in.end(),
                     std::back_inserter ( t->operands ),
                     CASCloneObject()
                   );
}

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


// Constructors & Destructor
// ----------------------------------------------------------------------------
CASTerm::CASTerm() {
    meta.UnsetSingleValue();
}

CASTerm::~CASTerm() {
#ifdef SHOWCONSTRUCTOR
    std::cout << "# CASTerm::~CASTerm()" << std::endl;
#endif
    std::for_each ( operands.begin(),
                    operands.end(),
                    CASDestroyObject() );
}
// ----------------------------------------------------------------------------

// Public Methods
// ----------------------------------------------------------------------------

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

    if ( exp->IsZero() ) {
        LongInt *res = new LongInt ( 1L );
        return res;
    }
    CASTerm* result = dynamic_cast<CASTerm*> ( 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;

}

void
CASTerm::Append ( const CASObject* o ) {
    operands.push_back ( o->Clone() );
    meta.UnsetAll();
}

bool
CASTerm::IsEqual ( const CASObject* o ) const {
    checkptr ( o );

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

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

    if ( operands.size() != t_ptr->operands.size() ) {
        return false;
    }

    if ( !exponent->IsEqual ( t_ptr->exponent ) ) {
        return false;
    }

    return std::equal ( operands.begin(),
                        operands.end(),
                        t_ptr->operands.begin(),
                        CASObjectEqual() );
}

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

    return GetType() < o->GetType();
}

bool
CASTerm::IsGT ( const CASObject* o ) const {
    checkptr ( o );

    return GetType() > o->GetType();
}

unsigned long
CASTerm::NumOperands() const {
    return operands.size();
}

bool
CASTerm::IsPureNumerical() const {
    CASIsPureNumerical pn;
    pn = std::for_each ( operands.begin(), operands.end(), pn );
    return pn.Result();
}

CASObject*
CASTerm::SortWeight() const {
    CASCalculateSortWeight sortweight;
    sortweight = std::for_each ( operands.begin(),
                                 operands.end(),
                                 CASCalculateSortWeight() );
    return sortweight.Result();
}

void
CASTerm::Sort() {
    if ( meta.IsSorted() ) {
        return;
    }
    std::vector<CASObject*>::iterator i = operands.begin();
    while ( i != operands.end() ) {
        ( *i )->Sort();
        i++;
    }
    std::sort ( operands.begin(), operands.end(), CASSortObject() );
    meta.SetSorted();
}

void
CASTerm::UnsetAllEvaluated() {
    std::vector<CASObject*>::iterator it = operands.begin();
    while ( it != operands.end() ) {
        CASTerm *term = dynamic_cast<CASTerm*> ( *it );
        if ( term == 0 )
            ( *it )->meta.UnsetEvaluated();
        else
            term->UnsetAllEvaluated();
        it++;
    }
    meta.UnsetEvaluated();
}

void
CASTerm::SetAllEvaluated() {
    std::vector<CASObject*>::iterator it = operands.begin();
    while ( it != operands.end() ) {
        CASTerm *term = dynamic_cast<CASTerm*> ( *it );
        if ( term == 0 )
            ( *it )->meta.SetEvaluated();
        else
            term->SetAllEvaluated();
        it++;
    }
    meta.SetEvaluated();
}
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
// Operators
// ----------------------------------------------------------------------------

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

---