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

#include <iostream>
#include <algorithm>

#ifdef DEBUG
#include <cassert>
#endif

#include "casfuncobj.h"
#include "casexception.h"
#include "product.h"
#include "sum.h"
#include "longint.h"
#include "fraction.h"
#include "casconvert.h"

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

void
Product::GetOperandsWithoutCoefficient ( std::vector<const CASObject*>& lst ) const {
    std::transform ( operands.begin(),
                     operands.end(),
                     std::back_inserter ( lst ),
                     CASExtractNonCoefficients() );

    std::vector<const CASObject*>::iterator last =
        std::remove ( lst.begin(), lst.end(), ( ( CASObject* ) 0 ) );
    lst.erase ( last, lst.end() );

    // Here sort according value and type as expected by the cas methods
    std::sort ( lst.begin(), lst.end(), CASSortObject() );
}

const CASObject* Product::GetCoefficient() const {
    CASGetCoefficient coe;
    coe = std::for_each ( operands.begin(), operands.end(), coe );
    return coe.Result();
}

CASObject*
Product::CollectEqualOperands() const {
    Product *working_obj = dynamic_cast<Product*> ( Clone() );
#ifdef DEBUG2
    std::cout << "Product::CollectEqualOperands()" << std::endl;
    Print();
    std::cout << std::endl;
#endif
    bool exprmodified;
    do {
        exprmodified = false;
        resolve_parentheses<Product> ( working_obj );
        working_obj->Sort();
#ifdef DEBUG
        assert ( working_obj != 0 );
#endif

        std::vector<CASObject*>::const_iterator op_it = working_obj->operands.begin();
        std::vector<CASObject*>::const_iterator op_begin = op_it;
        std::vector<CASObject*>::const_iterator op_it_next = op_it;
        std::vector<CASObject*>::const_iterator op_end = working_obj->operands.end();

        // Get the iterator for the next object
        op_it_next++;

        // Holds the equal objects
        std::vector<CASObject*> equal_objs;

        // Temporary vector, which is later appended to the existing
        // one
        std::vector<CASObject*> new_operands;
        while ( op_it != op_end && op_it_next != op_end ) {
            while ( op_it != op_end &&
                    op_it_next != op_end &&
                    ( *op_it )->IsEqual ( *op_it_next ) ) {
                equal_objs.push_back ( *op_it );
                equal_objs.push_back ( *op_it_next );

                op_it++;
                op_it_next++;
            }

            // Now replace the found objects, if any
            if ( equal_objs.size() > 0 ) {
                exprmodified = true;

                // The above method for searching same operands yields
                // duplicate results thus we have to unique'ing the
                // equal_obj vector.  CASGarbageSort_Cmp() is used
                // because it sorts by memory address
                std::sort ( equal_objs.begin(), equal_objs.end(), CASGarbageSort_Cmp() );

                std::vector<CASObject*>::iterator ip =
                    std::unique ( equal_objs.begin(), equal_objs.end() );

                equal_objs.erase ( ip, equal_objs.end() );

                LongInt li_exponent ( equal_objs.size() );
                CASObject *res =
                    ( equal_objs.front() )->Power ( &li_exponent );

                new_operands.push_back ( res );

                // Now, destroy the equal operands, and zero 'em out
                std::vector<CASObject*>::const_iterator eqo_it = equal_objs.begin();
                while ( eqo_it != equal_objs.end() ) {
                    // find the operand in the operand vector, so we
                    // can set it to zero
                    CASObjectFindByAddr needle ( *eqo_it );
                    std::vector<CASObject*>::iterator pos =
                        std::find_if ( working_obj->operands.begin(),
                                       working_obj->operands.end(),
                                       needle );
#ifdef DEBUG
                    assert ( pos != op_end );
                    assert ( *pos != 0 );
#endif

                    *pos = 0;
                    CASObject::Garbage->Put ( *eqo_it );
                    eqo_it++;
                }
                // Finally, clear the list for the next iteration
                equal_objs.clear();
            } else {
                exprmodified = false;
            }

            op_it++;
            op_it_next++;
        }

        if ( new_operands.size() > 0 ) {
            // Remove the elements zero'ed out above and shrink
            // the vector.
            std::vector<CASObject*>::iterator last =
                std::remove ( working_obj->operands.begin(),
                                  working_obj->operands.end(),
                                  ( ( CASObject* ) 0 ) )
                    ;
            working_obj->operands.erase ( last, working_obj->operands.end() );

            std::copy ( new_operands.begin(),
                        new_operands.end(),
                        std::back_inserter ( working_obj->operands ) );

            new_operands.clear();

            working_obj->meta.UnsetSorted();
            working_obj->Sort();
        }
    } while ( exprmodified );

    return working_obj;
}

CASObject*
Product::CollectOther() const {
#ifdef DEBUG2
    std::cout << "Product::CollectOther()" << std::endl;
    Print();
    std::cout << std::endl;
#endif
    std::vector<CASObject*> newoperands;
    std::transform ( operands.begin(),
                     operands.end(),
                     back_inserter ( newoperands ),
                     CASCloneObject() );

    std::vector<CASObject*>::iterator it = newoperands.begin();
    std::vector<CASObject*>::iterator secondary_it;

    while ( it != newoperands.end() ) {
        secondary_it = it;
        secondary_it++;
        while ( secondary_it != newoperands.end() ) {
            bool similar = ( *it )->IsSimilar ( ( *secondary_it ) );
            if ( similar ) {
                CASObject *tmp = *secondary_it;
                *secondary_it = ( *it )->Multiply ( ( *secondary_it ) );
                CASObject::Garbage->Put ( tmp );
                CASObject::Garbage->Put ( ( *it ) );
                *it = 0;
                break;
            }

            secondary_it++;
        }

        it++;
    }

    it = std::remove ( newoperands.begin(),
                           newoperands.end(),
                           ( CASObject* ) 0 );
    newoperands.erase ( it, newoperands.end() );
    Product* result = new Product();
#ifdef DEBUG
    assert ( result->exponent != 0 );
#endif
    CASObject::Garbage->Put ( result->exponent );
    result->exponent = exponent->Clone();
    result->operands = newoperands;
    result->Sort();

    return result;

}

void
Product::ExplodeSumsIP() {
    std::vector<CASObject*>::iterator it = operands.begin();
    std::vector<CASObject*> exploded_sums;

    while ( it != operands.end() ) {
        if ( ( *it )->GetType() == CT_SUM &&
                ( *it )->exponent->GetType() == CT_LONGINT &&
                ! ( *it )->exponent->IsOne() ) {
            Sum *sum = dynamic_cast<Sum*> ( *it );
            LongInt *li_exp = dynamic_cast<LongInt*> ( sum->exponent );
#ifdef DEBUG
            assert ( li_exp != 0 );
            assert ( sum != 0 );
#endif
            Sum *sum_exp_one = dynamic_cast<Sum*> ( sum->Clone() );
#ifdef DEBUG
            assert ( sum_exp_one != 0 );
#endif
            CASObject::Garbage->Put ( sum_exp_one->exponent );
            LongInt li ( 1L );
            sum_exp_one->exponent = li.Clone();
            for ( li = 0; li < * ( li_exp ); li++ ) {
                exploded_sums.push_back ( sum_exp_one->Clone() );
            }
            ( *it ) = 0;

            CASObject::Garbage->Put ( sum );
            CASObject::Garbage->Put ( sum_exp_one );
        }
        it++;
    }
    std::vector<CASObject*>::iterator remove_it =
        std::remove ( operands.begin(),
                          operands.end(),
                          ( ( CASObject* ) 0 ) );
    operands.erase ( remove_it, operands.end() );
    std::copy ( exploded_sums.begin(),
                exploded_sums.end(),
                std::back_inserter ( operands )
              );
    return;
}

void
Product::GetSums ( const std::vector<const CASObject*> &in,
                   std::vector<const CASObject*> &out ) {
    for ( unsigned long i = 0; i < in.size(); i++ ) {
        if ( in[i]->GetType() == CT_SUM )
            out.push_back ( in[i] );
    }
}

void
Product::GetNonSums ( const std::vector<const CASObject*> &in,
                      std::vector<const CASObject*> &out ) {
    for ( unsigned long i = 0; i < in.size(); i++ ) {
        if ( in[i]->GetType() != CT_SUM )
            out.push_back ( in[i] );
    }
}
// ----------------------------------------------------------------------------



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

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

// Constructors & Destructor
// ----------------------------------------------------------------------------
Product::Product() : CASTerm() {
#ifdef SHOWCONSTRUCTOR
    std::cout << "# Product::Product()" << std::endl;
#endif
    LongInt one ( 1L );
    exponent = one.Clone();
}

Product::~Product() {
#ifdef SHOWCONSTRUCTOR
    std::cout << "# Product::~Product()" << std::endl;
#endif
#ifdef DEBUG
    assert ( exponent != 0 );
#endif
    delete exponent;
}

Product::Product ( const Product &p ) {
#ifdef SHOWCONSTRUCTOR
    std::cout << "# Product::Product(const Product &f)" << std::endl;
#endif

    std::transform ( p.operands.begin(),
                     p.operands.end(),
                     std::back_inserter ( operands ),
                     CASCloneObject() );
    meta = p.meta;
    exponent = p.exponent->Clone();
}

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


// Public Methods
// ----------------------------------------------------------------------------
CASObject*
Product::Clone() const {
    Product *ret_val = new Product;

    *ret_val = *this;

    return ret_val;
}

void
Product::Get ( std::string &s ) const {
    s.erase();
    std::string tmp;

#ifdef DEBUG
    s = "[";
#endif

    if ( !exponent->IsOne() ) {
#ifdef DEBUG
        s += "(";
#else
        s = "(";
#endif
    }

    for ( unsigned long i = 0; i < operands.size(); i++ ) {
#ifdef DEBUG
        assert ( operands[i] != 0 );
#endif
        if ( i > 0 ) {
            s += "*";
        }

        if ( operands[i]->GetType() == CT_SUM ) {
            s += "(";
        }

        operands[i]->Get ( tmp );

        s += tmp;

        if ( operands[i]->GetType() == CT_SUM ) {
            s += ")";
        }
    }

    if ( !exponent->IsOne() ) {
        s += ")^";
        exponent->Get ( tmp );
        if ( !exponent->meta.IsSingleValue() ) {
            s += "(" + tmp + ")";
        } else {
            s += tmp;
        }
    }
#ifdef DEBUG
    s += "]";
#endif
}

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

unsigned long
Product::Length() const {
    unsigned long len = 0;

    for ( unsigned long i = 0; i < operands.size(); i++ ) {
#ifdef DEBUG
        assert ( operands[i] != 0 );
#endif

        len += operands[i]->Length();
    }

    // Add the size of the operators '*'
    len += operands.size() - 1;

    return len;
}

bool
Product::IsZero() const {
    if ( operands.size() == 0 )
        return true;

    for ( unsigned long i = 0; i < operands.size(); i++ ) {
#ifdef DEBUG
        assert ( operands[i] != 0 );
#endif

        if ( operands[i]->IsZero() ) {
            return true;
        }
    }

    return false;
}

bool
Product::IsOne() const {
    for ( unsigned long i = 0; i < operands.size(); i++ ) {
#ifdef DEBUG
        assert ( operands[i] != 0 );
#endif

        if ( !operands[i]->IsOne() ) {
            return false;
        }
    }

    return true;

}

bool
Product::IsSimilar ( const CASObject *o ) const {
    checkptr ( o );
#ifdef DEBUG2
    std::cout << "Object to search for similarity: ";
    o->Print();
    std::cout << std::endl;
#endif

    if ( !o->meta.IsSingleValue() && ( GetType() != o->GetType() ) ) {
        return false;
    }
    if ( IsEqual ( o ) ) {
        return true;
    }

    std::vector<const CASObject*> ops_without_coeff;
    GetOperandsWithoutCoefficient ( ops_without_coeff );
#ifdef DEBUG
    assert ( ops_without_coeff.size() > 0 );
#endif

    CASConvert convert ( ops_without_coeff );

    Product *tmp_prod;
    try {
        tmp_prod = convert.ToProduct();
    } catch ( EDoesNotApply &e ) {
#ifdef DEBUG2
        std::cout << "Catched exception EDoesNotApply()";
#endif
        return false;
    }

    CASConvert convert_o ( o );
    Product* converted_o;
    try {
        converted_o = convert_o.ToProduct();
    } catch ( EDoesNotApply &e ) {
#ifdef DEBUG2
        std::cout << "Catched exception EDoesNotApply()";
#endif
        CASObject::Garbage->Put ( tmp_prod );
        return false;
    }

    // Since it is a Product now, we extract only non-coefficients
    std::vector<const CASObject*> o_ops_without_coeff;
    converted_o->GetOperandsWithoutCoefficient ( o_ops_without_coeff );

    CASConvert non_coeff_conv ( o_ops_without_coeff );
    Product* final_o_conversion;
    try {
        final_o_conversion = non_coeff_conv.ToProduct();
    } catch ( EDoesNotApply &e ) {
#ifdef DEBUG2
        std::cout << "Catched exception EDoesNotApply()";
#endif
        CASObject::Garbage->Put ( tmp_prod );
        CASObject::Garbage->Put ( converted_o );
        return false;
    }



    bool ret_val = tmp_prod->IsEqual ( final_o_conversion );
    CASObject::Garbage->Put ( final_o_conversion );
    CASObject::Garbage->Put ( converted_o );
    CASObject::Garbage->Put ( tmp_prod );

    return ret_val;
}

CASObject*
Product::Absolute() const {
    Product *tmp = new Product;
    *tmp = *this;

    std::for_each ( tmp->operands.begin(),
                    tmp->operands.end(),
                    CASAbsoluteObjectIP() );

    return tmp;
}


void
Product::AbsoluteIP() {
    std::for_each ( operands.begin(), operands.end(), CASAbsoluteObjectIP() );
}

CASObject*
Product::Invert() const {
    Product *tmp = new Product;
    *tmp = *this;

    std::for_each ( tmp->operands.begin(),
                    tmp->operands.end(),
                    CASInvertObjectIP() );

    return tmp;
}

void
Product::InvertIP() {
    std::for_each ( operands.begin(), operands.end(), CASInvertObjectIP() );
}

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

    // Retrieve the operands without coefficients from this product.
    std::vector<const CASObject*> this_noncoe;
    GetOperandsWithoutCoefficient ( this_noncoe );
#if defined(DEBUG)
    assert ( this_noncoe.size() > 0 );
#endif
    const CASObject *this_coeff = GetCoefficient();

    if ( GetType() == addend->GetType() ) {
        const Product *arg_obj = dynamic_cast<const Product*> ( addend );
#if defined(DEBUG)
        assert ( arg_obj != 0 );
#endif

        // Retrieve the operands without coefficients from the product
        // supplied as argument
        std::vector<const CASObject*> arg_noncoe;
        arg_obj->GetOperandsWithoutCoefficient ( arg_noncoe );
#if defined(DEBUG)
        assert ( arg_noncoe.size() > 0 );
#endif

        bool equal = false;
        if ( this_noncoe.size() == arg_noncoe.size() ) {
            equal = std::equal ( this_noncoe.begin(),
                                 this_noncoe.end(),
                                 arg_noncoe.begin(),
                                 CASObjectEqual() );
        }
        // Check if the vectors holding the non-coefficient operands
        // are equal, if they are not, simply fall thru the end of the
        // method
        if ( equal ) {
            // Because both products are equal regarding
            // non-coefficients we have to compute the new
            // coefficient. The non-coefficients are appended to the
            // result at the bottom of this scope
            Product *result = new Product;

            const CASObject *arg_coeff = arg_obj->GetCoefficient();
#if  defined(DEBUG)
            // In debug mode, make sure both objects are pure
            // numerical values
            if ( this_coeff != 0 ) {
                assert ( this_coeff->IsPureNumerical() );
            }
            if ( arg_coeff != 0 ) {
                assert ( arg_coeff->IsPureNumerical() );
            }
#endif

            // Compute the new coefficient depending on the existing
            // coefficients
            if ( this_coeff != 0 && arg_coeff != 0 ) {
                CASObject *new_coeff = this_coeff->Add ( arg_coeff );
                result->Append ( new_coeff );
                // The new coefficient is no longer needed, since
                CASObject::Garbage->Put ( new_coeff );
            } else {
                // Now we have to find out which coefficient exists,
                // the one from this product, or the one in the
                // product supplied as argument. Worst case, both do
                // not have an coefficient...
                if ( this_coeff == 0 && arg_coeff == 0 ) {
                    LongInt new_coeff ( 2L );
                    result->Append ( &new_coeff );
                }

                LongInt one ( 1L );
                CASObject *new_coeff;
                if ( this_coeff != 0 ) {
                    new_coeff = this_coeff->Add ( &one );
                    result->Append ( new_coeff );
                    CASObject::Garbage->Put ( new_coeff );
                }

                if ( arg_coeff != 0 ) {
                    new_coeff = arg_coeff->Add ( &one );
                    result->Append ( new_coeff );
                    CASObject::Garbage->Put ( new_coeff );
                }
            }


            // Now append the non-coefficients to the result
            std::transform ( this_noncoe.begin(), this_noncoe.end(),
                             back_inserter ( result->operands ), CASCloneObject() );
            return result;
        }
    } else {
        // Here we see if we deal with a single argument
        if ( this_noncoe.size() == 1 ) {
            if ( addend->IsEqual ( this_noncoe[0] ) ) {
                Product *result = new Product;
                result->Append ( addend );
                if ( this_coeff != 0 ) {
                    LongInt one ( 1L );
                    CASObject *new_coeff = this_coeff->Add ( &one );
                    new_coeff->meta.SetCoefficient();
                    result->Append ( new_coeff );
                    CASObject::Garbage->Put ( new_coeff );
                } else {
                    LongInt two ( 2L );
                    two.meta.SetCoefficient();
                    result->Append ( &two );
                }
                return result;
            }
        }
        // Simply fall thru
    }
    Sum *result = new Sum;
    result->Append ( this );
    result->Append ( addend );

    return result;
}

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

    Sum *result = new Sum;
    result->Append ( this );
    CASObject* inv_subtrahend = subtrahend->Invert();
    result->Append ( inv_subtrahend );

    CASObject::Garbage->Put ( inv_subtrahend );
    return result;
}

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

    Product *NewProd = new Product;
    *NewProd = *this;
    NewProd->meta.UnsetSorted();

    if ( GetType() == factor->GetType() ) {

        const Product *pr_ptr = dynamic_cast<const Product *> ( factor );
#ifdef DEBUG
        assert ( pr_ptr != 0 );
#endif

        std::transform ( pr_ptr->operands.begin(),
                         pr_ptr->operands.end(),
                         back_inserter ( NewProd->operands ),
                         CASCloneObject() );
    } else {
        std::vector<CASObject*>::iterator pi = find_if ( NewProd->operands.begin(),
                                               NewProd->operands.end(),
                                               CASTypeFinder_EQ ( factor ) );

        if ( pi != NewProd->operands.end() ) {
            // Compute the product
            CASObject *result = ( *pi )->Multiply ( factor );
            // Free the memory occupied by the existing item
            CASObject::Garbage->Put ( *pi );
            // Remove the item from the vector
            NewProd->operands.erase ( pi );
            // Add the result
            if ( result->IsPureNumerical() ) {
                result->meta.SetCoefficient();
                NewProd->operands.push_back ( result );
            } else {
                // See if it is of the type Product, so we can incorporate
                // the operands directly into the ones of "result"
                if ( GetType() == result->GetType() ) {
                    Product *result_prod = dynamic_cast<Product*> ( result );
#ifdef DEBUG
                    assert ( result_prod != 0 );
#endif
                    std::copy ( result_prod->operands.begin(),
                                result_prod->operands.end(),
                                back_inserter ( NewProd->operands ) );
                } else {
                    NewProd->operands.push_back ( result );
                }
            }

        } else {
            CASObject *tmp = factor->Clone();
            if ( tmp->IsPureNumerical() ) {
                tmp->meta.SetCoefficient();
            }
            NewProd->operands.push_back ( tmp );
        }
    }

    return NewProd;
}

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

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

    return result;
}

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

CASObject*
Product::GCD ( const CASObject* o ) const {
#ifdef WARNINGS
#warning "Not fully implemented: Product::GCD(const CASObject*) const"
#endif

    checkptr ( o );
    return new LongInt ( 1L );
}

CASObject*
Product::Evaluate() const {
    if ( meta.IsEvaluated() ) {
        return Clone();
    }

#ifdef DEBUG2
    std::cout << ">>> Begin evaluation of ";
    Print();
    std::cout << std::endl;
#endif

    Product *tmp = dynamic_cast<Product*> ( Clone() );
#ifdef DEBUG
    assert ( tmp != 0 );
#endif
    tmp->UnsetAllEvaluated();
    resolve_parentheses<Product> ( tmp );
    evaluate_operands<Product> ( tmp );

    CASObject* result = tmp->Collect();
    CASObject::Garbage->Put ( tmp );

    result->meta.SetEvaluated();
    CASTerm *term = dynamic_cast<CASTerm*> ( result );
    if ( term != 0 ) {
        term->RemoveNoOpElements();
        if ( term->IsOne() ) {
            CASObject::Garbage->Put ( result );
            LongInt r ( 1L );
            return r.Clone();
        }
        term->SetAllEvaluated();
    }

    if ( result->IsOne() ) {
        CASObject::Garbage->Put ( result );
        LongInt r ( 1L );
        return r.Clone();
    }

    if ( result->IsZero() ) {
        CASObject::Garbage->Put ( result );
        LongInt r ( 0L );
        return r.Clone();
    }

#ifdef DEBUG2
    std::cout << ">>> End evaluation of ";
    Print();
    std::cout << std::endl;
#endif

    return result;
}

CASObject*
Product::Collect() const {
    Product *product = dynamic_cast<Product*> ( Clone() );

    CASObject* tmp = product->CollectEqualOperands();
#ifdef DEBUG
    checkptr ( tmp );
#endif
    CASObject::Garbage->Put ( product );

    product = dynamic_cast<Product*> ( tmp );
    if ( product == 0 ) {
        return tmp;
    }

    tmp = product->CollectOther();
    CASObject::Garbage->Put ( product );

    return tmp;

}

CASObject*
Product::Expand() const {
    if ( !meta.IsEvaluated() ) {
        throw EEvaluateFirst();
    }
    CASObject *clone = Clone();

    Product *wrking = dynamic_cast<Product*> ( clone );
#ifdef DEBUG
    assert ( wrking != 0 );
#endif
    wrking->ExplodeSumsIP();

    // Preparations
    resolve_parentheses<Product> ( wrking );

    std::vector<const CASObject*> non_singleval;
    wrking->GetNonSingleValues ( non_singleval );

    std::vector<const CASObject*> sums_only;
    std::vector<const CASObject*>::const_iterator sums_only_it;
    wrking->GetSums ( non_singleval, sums_only );
    if ( sums_only.size() == 0 ) {
        CASObject::Garbage->Put ( wrking );
        return Clone();
    }

    std::vector<const CASObject*> nonsums_only;
    std::vector<const CASObject*>::const_iterator nonsums_only_it;
    wrking->GetNonSums ( non_singleval, nonsums_only );
#ifdef DEBUG
    assert ( nonsums_only.size() + sums_only.size() == non_singleval.size() );
#endif

    std::vector<const CASObject*>::const_iterator singleval_it;
    std::vector<const CASObject*> singleval;
    wrking->GetSingleValues ( singleval );

    std::vector<CASObject*> result_vector;
    std::vector<CASObject*>::iterator result_it;

    std::vector<const CASObject*> temp_operands;
    std::vector<const CASObject*>::const_iterator temp_operands_it;


    // Expanding starts
    sums_only_it = sums_only.begin();
    const Sum* temp_sum = dynamic_cast<const Sum*> ( *sums_only_it );
#ifdef DEBUG
    assert ( temp_sum != 0 );
#endif

    GetOperands ( temp_sum, temp_operands );


    std::transform ( temp_operands.begin(),
                     temp_operands.end(),
                     std::back_inserter ( result_vector ),
                     CASCloneObject()
                   );

    std::vector<CASObject*> intermediate_results;
    // The first item was already processed
    sums_only_it++;
    // Expand the sums
    while ( sums_only_it != sums_only.end() ) {
        temp_sum = dynamic_cast<const Sum*> ( *sums_only_it );
#ifdef DEBUG
        assert ( temp_sum != 0 );
#endif
        temp_operands.clear();
        GetOperands ( temp_sum, temp_operands );

        result_it = result_vector.begin();
        while ( result_it != result_vector.end() ) {
            temp_operands_it = temp_operands.begin();
            while ( temp_operands_it != temp_operands.end() ) {
                intermediate_results.push_back ( ( *result_it )->Multiply ( *temp_operands_it ) );
                temp_operands_it++;
            }
            result_it++;
        }
        CASObject::Garbage->Put ( result_vector );
        result_vector.clear();
        std::copy ( intermediate_results.begin(),
                    intermediate_results.end(),
                    std::back_inserter ( result_vector )
                  );
        intermediate_results.clear();
        sums_only_it++;
    }
#ifdef DEBUG
    assert ( intermediate_results.size() == 0 );
#endif

    // Distribute the single values
    singleval_it = singleval.begin();
    while ( singleval_it != singleval.end() ) {
        result_it = result_vector.begin();
        while ( result_it != result_vector.end() ) {
            intermediate_results.push_back ( ( *result_it )->Multiply ( *singleval_it ) );
            result_it++;
        }
        CASObject::Garbage->Put ( result_vector );
        result_vector.clear();
        std::copy ( intermediate_results.begin(),
                    intermediate_results.end(),
                    std::back_inserter ( result_vector )
                  );
        intermediate_results.clear();
        singleval_it++;
    }
#ifdef DEBUG
    assert ( intermediate_results.size() == 0 );
#endif

    // Distribute the leftover, aka. nonsums only
    nonsums_only_it = nonsums_only.begin();
    while ( nonsums_only_it != nonsums_only.end() ) {
        result_it = result_vector.begin();
        while ( result_it != result_vector.end() ) {
            intermediate_results.push_back ( ( *result_it )->Multiply ( *nonsums_only_it ) );
            result_it++;
        }
        CASObject::Garbage->Put ( result_vector );
        result_vector.clear();
        std::copy ( intermediate_results.begin(),
                    intermediate_results.end(),
                    std::back_inserter ( result_vector )
                  );
        intermediate_results.clear();
        nonsums_only_it++;
    }
#ifdef DEBUG
    assert ( intermediate_results.size() == 0 );
#endif
    CASObject::Garbage->Put ( wrking );

    Sum *s = new Sum;
    SetOperands ( s, result_vector );
    CASObject::Garbage->Put ( result_vector );

    s->UnsetAllEvaluated();
    CASObject *result = s->Evaluate();
    CASObject::Garbage->Put ( s );

    return result;
}

void
Product::RemoveNoOpElements() {
    std::vector<CASObject*>::iterator it = operands.begin();
    while ( it != operands.end() ) {
        if ( ( *it )->IsOne() ) {
            CASObject::Garbage->Put ( *it );
            it = operands.erase ( it );
        } else {
            CASTerm *term = dynamic_cast<CASTerm*> ( *it );
            if ( term != 0 ) {
                term->RemoveNoOpElements();
            }
            it++;
        }
        // Iterator already incremented... no need for it++
    }
}

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

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

const Product&
Product::operator= ( const Product &p ) {
#ifdef SHOWCONSTRUCTOR
    std::cout << "# Product::operator=(const Product &p)" << std::endl;
#endif

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

    CASObject::Garbage->Put ( operands );

    operands.clear();

    std::transform ( p.operands.begin(),
                     p.operands.end(),
                     std::back_inserter ( operands ),
                     CASCloneObject() );

    meta = p.meta;

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

    return *this;
}
// ----------------------------------------------------------------------------

---