CNormalTranslation Class Reference

#include <CNormalTranslation.h>

Collaboration diagram for CNormalTranslation:

Static Public Member Functions
static CEvaluationNode *	createChain (const CEvaluationNode *pLink, const CEvaluationNode *pNeutralElement, const std::vector< const CEvaluationNode * > &elements)
static CEvaluationNode *	createChain (const CEvaluationNode *pLink, const CEvaluationNode *pNeutralElement, const std::vector< CEvaluationNode * > &elements)
static CEvaluationNode *	createOperatorChain (CEvaluationNodeOperator::SubType type, const char *data, const std::vector< CEvaluationNode * > &nodes)
static CEvaluationNode *	createOperatorChain (CEvaluationNodeOperator::SubType type, const char *data, const std::vector< const CEvaluationNode * > &nodes)
static CEvaluationNode *	expandPowerBases (const CEvaluationNode *pRoot)
static CEvaluationNode *	expandPowerExponents (const CEvaluationNode *pRoot)
static CEvaluationNode *	expandProducts (const CEvaluationNode *pOrig)
static void	findSummands (const CEvaluationNode *pRoot, std::vector< const CEvaluationNode * > &summands)
static bool	has_duplicate_nodes (const CEvaluationNode *pNode)
static CEvaluationNode *	newEvaluateNumbers (const CEvaluationNode *pOrig)
static CNormalFraction *	normAndSimplify (const CEvaluationNode *root0)
static CNormalFraction *	normAndSimplifyReptdly (const CEvaluationTree *tree0, unsigned int depth=0)
static CNormalFraction *	normAndSimplifyReptdly (const CEvaluationNode *tree0, unsigned int depth=0)
static CEvaluationNode *	simplifyTree (const CEvaluationNode *node)
static CEvaluationNode *	simplifyTreeReptdly (const CEvaluationNode *root0)
static void	splitProduct (const CEvaluationNode *pRoot, std::vector< const CEvaluationNode * > &multiplications, std::vector< const CEvaluationNode * > &divisions, bool division)
static void	splitSum (const CEvaluationNode *pRoot, std::vector< CEvaluationNode * > &additions, std::vector< CEvaluationNode * > &substractions, bool minus)
static void	splitSum (const CEvaluationNode *pRoot, std::vector< const CEvaluationNode * > &additions, std::vector< const CEvaluationNode * > &substractions, bool minus)

Static Public Attributes
static const CEvaluationNode	NEUTRAL_ELEMENT_ADD = CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "0.0")
static const CEvaluationNode	NEUTRAL_ELEMENT_AND = CEvaluationNodeConstant(CEvaluationNodeConstant::TRUE, "TRUE")
static const CEvaluationNode	NEUTRAL_ELEMENT_MULTIPLY = CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0")
static const CEvaluationNode	NEUTRAL_ELEMENT_OR = CEvaluationNodeConstant(CEvaluationNodeConstant::FALSE, "FALSE")
static const CEvaluationNode	ONE_NODE = CNormalTranslation::NEUTRAL_ELEMENT_MULTIPLY
static const CEvaluationNode	PLUS_NODE = CEvaluationNodeOperator(CEvaluationNodeOperator::PLUS, "+")
static const CEvaluationNode	TIMES_NODE = CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*")
static const CEvaluationNode	ZERO_NODE = CNormalTranslation::NEUTRAL_ELEMENT_ADD

Static Protected Member Functions
static CEvaluationNode *	elementaryElimination (CEvaluationNode *pOrig)
static CEvaluationNode *	elementaryEliminationDivide (const CEvaluationNode *pDivideNode)
static CEvaluationNode *	elementaryEliminationFunction (const CEvaluationNode *pFunctionNode)
static CEvaluationNode *	elementaryEliminationMinus (const CEvaluationNode *pMinusNode)
static CEvaluationNode *	elementaryEliminationModulus (const CEvaluationNode *pModulusNode)
static CEvaluationNode *	elementaryEliminationMultiply (const CEvaluationNode *pMultiplyNode)
static CEvaluationNode *	elementaryEliminationPlus (const CEvaluationNode *pPlusNode)
static CEvaluationNode *	elementaryEliminationPower (const CEvaluationNode *pPowerNode)
static CEvaluationNode *	eliminate (const CEvaluationNode *pOrig)
static CEvaluationNode *	eliminateDirectlyNestedFractions (const CEvaluationNode *pOrig)
static CEvaluationNode *	eliminateNestedPowers (const CEvaluationNode *pOrig)
static CEvaluationNode *	eliminatePowersOfFractions (const CEvaluationNode *pOrig)
static CEvaluationNode *	expandPowerNodes (const CEvaluationNode *pOrig)
static std::pair < CEvaluationNode *, CEvaluationNode * >	factorize (const std::vector< CEvaluationNode * > &additions, const std::vector< CEvaluationNode * > &subtractions)
static void	findNegativeNumbers (std::vector< const CEvaluationNode * > &v1, std::vector< CEvaluationNode * > &v2)
static std::vector< product_match >	matchPowerBases (const std::vector< const CEvaluationNode * > &multiplications, const std::vector< const CEvaluationNode * > &divisions)
static std::vector< std::pair < CEvaluationNode *, CEvaluationNode * > >	matchSummands (const std::vector< CEvaluationNode * > &additions, const std::vector< CEvaluationNode * > &subtractions)
static std::vector< summ_match >	matchSummands (const std::vector< const CEvaluationNode * > &additions, const std::vector< const CEvaluationNode * > &subtractions)
static CEvaluationNode *	multiply (const CEvaluationNode *pNode1, const CEvaluationNode *pNode2)
static CEvaluationNode *	newCancel (const CEvaluationNode *pOrig)
static void	order (const CEvaluationNode *pRoot, std::list< const CEvaluationNode * > &orderList)
static void	printPointers (const CEvaluationNode *pNode, const char *indent="")
static CEvaluationNode *	product2fraction (const CEvaluationNode *pOrig)
static CEvaluationNode *	simplify (const CEvaluationNode *pOrig)
static void	swapNegativeNumbers (std::vector< CEvaluationNode * > &v1, std::vector< CEvaluationNode * > &v2)

Static Protected Attributes
static const unsigned int	RECURSION_LIMIT = 20
static const double	ZERO = 1e-100

Detailed Description

The class for simplification and translation of trees into CNormal

Definition at line 84 of file CNormalTranslation.h.

Member Function Documentation

CEvaluationNode * CNormalTranslation::createChain ( const CEvaluationNode *  pLink, const CEvaluationNode *  pNeutralElement, const std::vector< const CEvaluationNode * > &  elements  )

static

More general version of createOperatorChain. This method can also be used to combine logical item chains. Once I know this works, I will replace createOperatorChain with this method.

This version of create chain copies the given elements in the vector and then calls the createChain method which does not need copying.

Definition at line 5905 of file CNormalTranslation.cpp.

Referenced by convertToCEvaluationNode(), createFraction(), createProduct(), expandPowerBases(), expandPowerExponents(), expandPowerNodes(), factorize(), matchSummands(), multiply(), newCancel(), and newEvaluateNumbers().

{
  std::vector<CEvaluationNode*> tmpVector;
  tmpVector.reserve(elements.size());
  std::vector<const CEvaluationNode*>::const_iterator it = elements.begin(), endit = elements.end();

  while (it != endit)
    {
      tmpVector.push_back((*it)->copyBranch());
      ++it;
    }

  return CNormalTranslation::createChain(pLink, pNeutralElement, tmpVector);
}

CEvaluationNode * CNormalTranslation::createChain ( const CEvaluationNode *  pLink, const CEvaluationNode *  pNeutralElement, const std::vector< CEvaluationNode * > &  elements  )

static

More general version of createOperatorChain. This version does not copy the nodes in the given vector, but uses them directly. This method can also be used to combine logical item chains. method.

This method creates a chain of operations. The individual elements are linked with copies of pLink. NULL is returned if elements is empty. So if this method is used to create a chanin of OR linked elements which will be embedded in another and linked chain, the neutral element should be a TRUE node since AND combining something with true does not change the result. The neutral element is the element that does not change the result of the operation represented be pLink. So if pLink represents a multiplication, the neutral element is the number node 1.0. This method does not copy the elements in the given vector, but uses them in the chain directly.

Definition at line 5933 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNode::copyBranch(), and pResult.

{
  CEvaluationNode* pResult = NULL;

  if (elements.size() == 1)
    {
      pResult = elements[0];
    }
  else if (elements.size() > 1)
    {
      std::vector<CEvaluationNode*>::const_reverse_iterator it = elements.rbegin(), endit = elements.rend();
      CEvaluationNode* pOperator = pLink->copyBranch();
      CEvaluationNode* pChild = *it;
      ++it;
      pOperator->addChild(*it);
      pOperator->addChild(pChild);
      ++it;
      pChild = pOperator;

      while (it != endit)
        {
          pOperator = pLink->copyBranch();
          pOperator->addChild(*it);
          pOperator->addChild(pChild);
          pChild = pOperator;
          ++it;
        }

      pResult = pOperator;
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::createOperatorChain ( CEvaluationNodeOperator::SubType  type, const char *  data, const std::vector< CEvaluationNode * > &  nodes  )

static

Given a vector of nodes, this method creates a multiplication chain of all the nodes. The chain contains copies of the nodes passed in.

Given a vector of nodes, this method creates a multiplication chain of all the nodes. The chain contains the original nodes and not copies.

Definition at line 5887 of file CNormalTranslation.cpp.

Referenced by factorize(), and matchSummands().

{
  std::vector<const CEvaluationNode*> tmpV;
  std::vector<CEvaluationNode*>::const_iterator it = nodes.begin(), endit = nodes.end();

  while (it != endit)
    {
      tmpV.push_back(*it);
      ++it;
    }

  return CNormalTranslation::createOperatorChain(type, data, tmpV);
}

CEvaluationNode * CNormalTranslation::createOperatorChain ( CEvaluationNodeOperator::SubType  type, const char *  data, const std::vector< const CEvaluationNode * > &  nodes  )

static

Given a vector of nodes, this method creates a multiplication chain of all the nodes. The chain contains copies of the nodes passed in.

Concatenates the goven nodes by the given operation. So if the nodes are node1, node2,node3 and the operation is multiplication, this will create node1 * node2 * node3 The node that is returned contains copies of the original nodes and the caller is responsible for freeing the memory.

Definition at line 298 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNode::copyBranch(), CEvaluationNodeNumber::DOUBLE, and pResult.

{
  CEvaluationNode* pResult = NULL;

  if (nodes.size() == 0)
    {
      pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0");
    }
  else if (nodes.size() == 1)
    {
      pResult = nodes[0]->copyBranch();
    }
  else
    {
      // start from the back to create the deepest nodes first
      std::vector<const CEvaluationNode*>::const_reverse_iterator it = nodes.rbegin(), endit = nodes.rend();
      CEvaluationNode* pOperator = new CEvaluationNodeOperator(type, data);
      CEvaluationNode* pChild2 = (*it)->copyBranch();
      ++it;
      CEvaluationNode* pChild1 = (*it)->copyBranch();
      pOperator->addChild(pChild1);
      pOperator->addChild(pChild2);
      ++it;
      pChild2 = pOperator;

      while (it != endit)
        {
          pOperator = new CEvaluationNodeOperator(type, data);
          pOperator->addChild((*it)->copyBranch());
          pOperator->addChild(pChild2);
          pChild2 = pOperator;
          ++it;
        }

      pResult = pOperator;
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::elementaryElimination ( CEvaluationNode *  pOrig )

staticprotected

This routine is responsible for all elementary eliminations, e.g. addition of 0. These steps can not lead to new simplifications in the children of the node being simplified, so it is not necessary to run this on the children again.

This routine is responsible for all elementary eliminations, e.g. addition of 0. These steps can not lead to new simplifications in the children of the node being simplified, so it is not necessary to run this on the children again.

Calls one of the following: elementaryEliminationPower elementaryEliminationModulus elementaryEliminationMultiply elementaryEliminationDivide elementaryEliminationPlus elementaryEliminationMinus elementaryEliminationFunction

Which method is called depends on the node passed to the method. The method is called recursively on the children of the passed in node.

Definition at line 622 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNodeOperator::DIVIDE, elementaryEliminationDivide(), elementaryEliminationFunction(), elementaryEliminationMinus(), elementaryEliminationModulus(), elementaryEliminationMultiply(), elementaryEliminationPlus(), elementaryEliminationPower(), fatalError, CEvaluationNode::FUNCTION, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNodeOperator::MINUS, CEvaluationNodeOperator::MODULUS, CEvaluationNodeOperator::MULTIPLY, CEvaluationNode::OPERATOR, CEvaluationNodeOperator::PLUS, CEvaluationNodeOperator::POWER, pResult, CCopasiNode< _Data >::removeChild(), CEvaluationNode::subType(), and CEvaluationNode::type().

Referenced by eliminate().

{
  // this is done depth first
  CEvaluationNode* pResult = pOrig;
  CEvaluationNode* pChild = dynamic_cast<CEvaluationNode*>(pOrig->getChild());
  CEvaluationNode* pLastChild = pOrig;

  while (pChild != NULL)
    {
      CEvaluationNode* pNewChild = elementaryElimination(pChild);
      assert(pNewChild != NULL);

      if (pNewChild != pChild)
        {
          // remove the old child and add the new one
          pOrig->removeChild(pChild);
          delete pChild;
          pChild = pNewChild;
          pOrig->addChild(pNewChild, pLastChild);
        }

      pLastChild = pChild;
      pChild = dynamic_cast<CEvaluationNode*>(pChild->getSibling());
    }

  if (CEvaluationNode::type(pOrig->getType()) == CEvaluationNode::OPERATOR)
    {
      // check if we can eliminate anything
      // check if one of the children is (-)0, (-)1, NaN or INFINITY
      switch ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pOrig->getType()))
        {
          case CEvaluationNodeOperator::POWER:
            pResult = CNormalTranslation::elementaryEliminationPower(pOrig);
            break;
          case CEvaluationNodeOperator::MODULUS:
            pResult = CNormalTranslation::elementaryEliminationModulus(pOrig);
            break;
          case CEvaluationNodeOperator::MULTIPLY:
            pResult = CNormalTranslation::elementaryEliminationMultiply(pOrig);
            break;
          case CEvaluationNodeOperator::DIVIDE:
            pResult = CNormalTranslation::elementaryEliminationDivide(pOrig);
            break;
          case CEvaluationNodeOperator::PLUS:
            pResult = CNormalTranslation::elementaryEliminationPlus(pOrig);
            break;
          case CEvaluationNodeOperator::MINUS:
            pResult = CNormalTranslation::elementaryEliminationMinus(pOrig);
            break;
          default:
            // we should never end up here
            fatalError();
            break;
        }
    }
  else if (CEvaluationNode::type(pOrig->getType()) == CEvaluationNode::FUNCTION)
    {
      pResult = CNormalTranslation::elementaryEliminationFunction(pOrig);
    }

  if (pResult == NULL)
    {
      pResult = pOrig;
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::elementaryEliminationDivide ( const CEvaluationNode *  pDivideNode )

staticprotected

This method makes the elementary elimination on a divide node.

This method makes the elementary elimination on a divide node.

The following eliminations are made: a) Nan / x -> Nan b) x / NaN -> NaN c) x / 0 -> NaN d) 0 / x -> 0 e) x / x -> 1 f) x / 1 -> x

The caller is responsible for freeing the memory for the returned object.

Definition at line 1116 of file CNormalTranslation.cpp.

References CEvaluationNodeConstant::_NaN, CEvaluationNode::CONSTANT, CEvaluationNode::copyBranch(), createNormalRepresentation(), CEvaluationNodeOperator::DIVIDE, CEvaluationNodeNumber::DOUBLE, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNode::NUMBER, CEvaluationNode::OPERATOR, pResult, CEvaluationNode::subType(), CNormalFraction::toString(), CEvaluationNode::type(), and ZERO.

Referenced by elementaryElimination().

{
  CEvaluationNode* pResult = NULL;
  assert(CEvaluationNode::type(pDivideNode->getType()) == CEvaluationNode::OPERATOR);
  assert(((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pDivideNode->getType())) == CEvaluationNodeOperator::DIVIDE);
  const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(pDivideNode->getChild());
  assert(pChild1 != NULL);
  const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
  assert(pChild2 != NULL);
  assert(pChild2->getSibling() == NULL);
  // if one of the children is NaN, the result is NaN
  CNormalFraction* base1 = createNormalRepresentation(pChild1);
  CNormalFraction* base2 = createNormalRepresentation(pChild2);

  if ((CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::CONSTANT &&
       ((CEvaluationNodeConstant::SubType)(CEvaluationNode::subType(pChild1->getType()))) == CEvaluationNodeConstant::_NaN) ||
      (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::CONSTANT &&
       ((CEvaluationNodeConstant::SubType)(CEvaluationNode::subType(pChild2->getType()))) == CEvaluationNodeConstant::_NaN))
    {
      pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NAN");
    }
  // the second child is 0, the result is NaN
  else if ((CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER &&
            fabs(dynamic_cast<const CEvaluationNodeNumber*>(pChild2)->getValue()) < ZERO))
    {
      pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NaN");
    }
  // if the first child is 0, the result is 0
  else if ((CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::NUMBER &&
            fabs(dynamic_cast<const CEvaluationNodeNumber*>(pChild1)->getValue()) < ZERO))
    {
      pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "0.0");
    }
  // if both children are the same, the result is 1
  else if (base1->toString() == base2->toString())
    {
      pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0");
    }
  // if the second child is 1, the result is the first child
  else if ((CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER &&
            fabs(dynamic_cast<const CEvaluationNodeNumber*>(pChild2)->getValue() - 1.0) < ZERO))
    {
      pResult = pChild1->copyBranch();
    }

  delete base1;
  delete base2;
  base1 = NULL;
  base2 = NULL;
  return pResult;
}

CEvaluationNode * CNormalTranslation::elementaryEliminationFunction ( const CEvaluationNode *  pFunctionNode )

staticprotected

This method makes elementary eliminations on function nodes

This method makes elementary eliminations on function nodes The elimiation made here are:

a) unary plus nodes are replaced by their child b) unary minus nodes of numbers are replaced by the corresponding number * -1 c) Function calls to NaN nodes are replaced by NaN

The node returned by this method is a new node and the caller is responsible for freeing the memory.

Definition at line 700 of file CNormalTranslation.cpp.

References CEvaluationNodeConstant::_NaN, CEvaluationNode::CONSTANT, CEvaluationNode::copyBranch(), CEvaluationNodeNumber::DOUBLE, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNodeFunction::INVALID, CEvaluationNodeFunction::MINUS, CEvaluationNodeOperator::MULTIPLY, CEvaluationNode::NUMBER, CEvaluationNodeFunction::PLUS, pResult, CEvaluationNode::subType(), and CEvaluationNode::type().

Referenced by elementaryElimination().

{
  // PLUS(X) -> X
  // X(NaN) -> NaN
  // MINUX(X) where X is a number -> -X
  CEvaluationNode* pResult = NULL;
  const CEvaluationNode* pChild = NULL;

  switch ((CEvaluationNodeFunction::SubType)CEvaluationNode::subType(pFunctionNode->getType()))
    {
      case CEvaluationNodeFunction::INVALID:
        break;
      case CEvaluationNodeFunction::PLUS:
        pChild = dynamic_cast<const CEvaluationNode*>(pFunctionNode->getChild());
        assert(pChild != NULL);
        assert(pChild->getSibling() == NULL);
        pResult = pChild->copyBranch();
        break;
      case CEvaluationNodeFunction::MINUS:
        pChild = dynamic_cast<const CEvaluationNode*>(pFunctionNode->getChild());
        assert(pChild != NULL);
        assert(pChild->getSibling() == NULL);

        if (CEvaluationNode::type(pChild->getType()) == CEvaluationNode::NUMBER)
          {
            std::ostringstream os;
            os.precision(18);
            os << -1.0*dynamic_cast<const CEvaluationNodeNumber*>(pChild)->getValue();
            pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str());
          }
        else if (CEvaluationNode::type(pChild->getType()) == CEvaluationNode::CONSTANT &&
                 ((CEvaluationNodeConstant::SubType)CEvaluationNode::subType(pChild->getType())) == CEvaluationNodeConstant::_NaN)
          {
            pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NaN");
          }

        if (pResult == NULL)
          {
            // MINUS(X) -> -1.0 * X
            pResult = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
            pResult->addChild(new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "-1.0"));
            pResult->addChild(pChild->copyBranch());
          }

        break;
      default:
        pChild = dynamic_cast<const CEvaluationNode*>(pFunctionNode->getChild());

        while (pChild != NULL)
          {
            if (CEvaluationNode::type(pChild->getType()) == CEvaluationNode::CONSTANT && ((CEvaluationNodeConstant::SubType)CEvaluationNode::subType(pChild->getType())) == CEvaluationNodeConstant::_NaN)
              {
                pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NaN");
                break;
              }

            pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling());
          }

        break;
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::elementaryEliminationMinus ( const CEvaluationNode *  pMinusNode )

staticprotected

This method makes the elementary elimination on a minus node.

This method makes the elementary elimination on a minus node. The following eliminations are made: a) NaN - x -> NaN b) x - NaN -> NaN c) x - x -> 0 d) x - 0 -> x e) 0 - x -> -1 * x

The caller is responsible for freeing the memory of the returned object.

Definition at line 1222 of file CNormalTranslation.cpp.

References CEvaluationNodeConstant::_NaN, CCopasiNode< _Data >::addChild(), CEvaluationNode::CONSTANT, CEvaluationNode::copyBranch(), createNormalRepresentation(), CEvaluationNodeNumber::DOUBLE, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNodeOperator::MINUS, CEvaluationNodeOperator::MULTIPLY, CEvaluationNode::NUMBER, CEvaluationNode::OPERATOR, pResult, CEvaluationNode::subType(), CNormalFraction::toString(), CEvaluationNode::type(), and ZERO.

Referenced by elementaryElimination().

{
  CEvaluationNode* pResult = NULL;
  assert(CEvaluationNode::type(pMinusNode->getType()) == CEvaluationNode::OPERATOR);
  assert(((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pMinusNode->getType())) == CEvaluationNodeOperator::MINUS);
  const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(pMinusNode->getChild());
  assert(pChild1 != NULL);
  const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
  assert(pChild2 != NULL);
  assert(pChild2->getSibling() == NULL);
  // if one child is NaN, the result is NaN (one could also consider to put
  // the second condition first so that to NaN would cancel each other out
  CNormalFraction* base1 = createNormalRepresentation(pChild1);
  CNormalFraction* base2 = createNormalRepresentation(pChild2);

  if ((CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::CONSTANT &&
       ((CEvaluationNodeConstant::SubType)(CEvaluationNode::subType(pChild1->getType()))) == CEvaluationNodeConstant::_NaN) ||
      (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::CONSTANT &&
       ((CEvaluationNodeConstant::SubType)(CEvaluationNode::subType(pChild2->getType()))) == CEvaluationNodeConstant::_NaN))
    {
      pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NAN");
    }
  // if both nodes are equal, the result is 0.0
  else if (base1->toString() == base2->toString())
    {
      pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "0.0");
    }
  // the second child is 0, the result is the first child
  else if ((CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER &&
            fabs(dynamic_cast<const CEvaluationNodeNumber*>(pChild2)->getValue()) < ZERO))
    {
      pResult = pChild1->copyBranch();
    }
  // if the first child is 0, the result is -1 times the second child
  else if ((CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::NUMBER &&
            fabs(dynamic_cast<const CEvaluationNodeNumber*>(pChild1)->getValue()) < ZERO))
    {
      pResult = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
      pResult->addChild(new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "-1.0"));
      pResult->addChild(pChild2->copyBranch());
    }

  delete base1;
  delete base2;
  base1 = NULL;
  base2 = NULL;
  return pResult;
}

CEvaluationNode * CNormalTranslation::elementaryEliminationModulus ( const CEvaluationNode *  pModulusNode )

staticprotected

This method makes the elementary elimination on a modulus node.

This method makes the elementary elimination on a modulus node. The following eliminations are made: a) NaNx -> NaN b) xNaN -> NaN c) xx -> 0 d) 0x -> 0 e) 1n -> 1 (n is a number, other than 1)

The caller is responsible for freeing the memory of the returned object.

Definition at line 987 of file CNormalTranslation.cpp.

References CEvaluationNodeConstant::_NaN, CEvaluationNode::CONSTANT, createNormalRepresentation(), CEvaluationNodeNumber::DOUBLE, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNode::getValue(), CEvaluationNodeOperator::MODULUS, CEvaluationNode::NUMBER, CEvaluationNode::OPERATOR, pResult, CEvaluationNode::subType(), CNormalFraction::toString(), CEvaluationNode::type(), and ZERO.

Referenced by elementaryElimination().

{
  CEvaluationNode* pResult = NULL;
  assert(CEvaluationNode::type(pModulusNode->getType()) == CEvaluationNode::OPERATOR);
  assert(((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pModulusNode->getType())) == CEvaluationNodeOperator::MODULUS);
  const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(pModulusNode->getChild());
  assert(pChild1 != NULL);
  const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
  assert(pChild2 != NULL);
  assert(pChild2->getSibling() == NULL);

  // if one child is NaN, the result is NaN
  if ((CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::CONSTANT &&
       ((CEvaluationNodeConstant::SubType)(CEvaluationNode::subType(pChild1->getType()))) == CEvaluationNodeConstant::_NaN) ||
      (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::CONSTANT &&
       ((CEvaluationNodeConstant::SubType)(CEvaluationNode::subType(pChild2->getType()))) == CEvaluationNodeConstant::_NaN))
    {
      pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NAN");
    }

  // X%X -> 0
  CNormalFraction* base1 = createNormalRepresentation(pChild1);
  CNormalFraction* base2 = createNormalRepresentation(pChild2);

  if (base1->toString() == base2->toString())
    {
      pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "0.0");
    }
  else if (CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::NUMBER)
    {
      // 0 and 1
      const CEvaluationNodeNumber* pNumberNode = dynamic_cast<const CEvaluationNodeNumber*>(pChild1);
      assert(pNumberNode != NULL);
      double value = pNumberNode->getValue();

      if (fabs(value) < ZERO)
        {
          pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "0.0");
        }
      else if (fabs(value - 1.0) < ZERO)
        {
          // 1%X where X is any number other than 1 will give 1.0
          // the case where X is 1 is already covered above
          if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER)
            {
              pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0");
            }
        }

      // ignore the rest
    }
  else if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER)
    {
      // 0 and 1
    }

  delete base1;
  delete base2;
  base1 = NULL;
  base2 = NULL;
  return pResult;
}

CEvaluationNode * CNormalTranslation::elementaryEliminationMultiply ( const CEvaluationNode *  pMultiplyNode )

staticprotected

This method makes the elementary elimination on a multiply node.

This method makes the elementary elimination on a multiply node. The following eliminations are made: a) NaN * x -> NaN b) 0 * x -> 0 c) 1 * x -> x

The caller is responsible for freeing the memory of the returned object.

Definition at line 1060 of file CNormalTranslation.cpp.

References CEvaluationNodeConstant::_NaN, CEvaluationNode::CONSTANT, CEvaluationNode::copyBranch(), CEvaluationNodeNumber::DOUBLE, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNodeOperator::MULTIPLY, CEvaluationNode::NUMBER, CEvaluationNode::OPERATOR, pResult, CEvaluationNode::subType(), CEvaluationNode::type(), and ZERO.

Referenced by elementaryElimination().

{
  CEvaluationNode* pResult = NULL;
  assert(CEvaluationNode::type(pMultiplyNode->getType()) == CEvaluationNode::OPERATOR);
  assert(((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pMultiplyNode->getType())) == CEvaluationNodeOperator::MULTIPLY);
  const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(pMultiplyNode->getChild());
  assert(pChild1 != NULL);
  const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
  assert(pChild2 != NULL);
  assert(pChild2->getSibling() == NULL);

  // if one child is NaN, the result is NaN
  if ((CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::CONSTANT &&
       ((CEvaluationNodeConstant::SubType)(CEvaluationNode::subType(pChild1->getType()))) == CEvaluationNodeConstant::_NaN) ||
      (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::CONSTANT &&
       ((CEvaluationNodeConstant::SubType)(CEvaluationNode::subType(pChild2->getType()))) == CEvaluationNodeConstant::_NaN))
    {
      pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NAN");
    }
  // if one child is 0, the result is 0
  else if ((CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::NUMBER &&
            fabs(dynamic_cast<const CEvaluationNodeNumber*>(pChild1)->getValue()) < ZERO) ||
           (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER &&
            fabs(dynamic_cast<const CEvaluationNodeNumber*>(pChild2)->getValue()) < ZERO))
    {
      pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "0.0");
    }
  // if one child is 1, the result is the other child
  else if ((CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::NUMBER &&
            fabs(dynamic_cast<const CEvaluationNodeNumber*>(pChild1)->getValue() - 1.0) < ZERO))
    {
      pResult = pChild2->copyBranch();
    }
  else if ((CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER &&
            fabs(dynamic_cast<const CEvaluationNodeNumber*>(pChild2)->getValue() - 1.0) < ZERO))
    {
      pResult = pChild1->copyBranch();
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::elementaryEliminationPlus ( const CEvaluationNode *  pPlusNode )

staticprotected

This method makes the elementary elimination on a plus node.

This method makes the elementary elimination on a plus node. The following eliminations are made: a) NaN + x -> NaN b) 0 + x -> x (also x + 0)

The caller is responsible for freeing the memory for the returned object.

Definition at line 1176 of file CNormalTranslation.cpp.

References CEvaluationNodeConstant::_NaN, CEvaluationNode::CONSTANT, CEvaluationNode::copyBranch(), CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNode::NUMBER, CEvaluationNode::OPERATOR, CEvaluationNodeOperator::PLUS, pResult, CEvaluationNode::subType(), CEvaluationNode::type(), and ZERO.

Referenced by elementaryElimination().

{
  CEvaluationNode* pResult = NULL;
  assert(CEvaluationNode::type(pPlusNode->getType()) == CEvaluationNode::OPERATOR);
  assert(((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pPlusNode->getType())) == CEvaluationNodeOperator::PLUS);
  const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(pPlusNode->getChild());
  assert(pChild1 != NULL);
  const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
  assert(pChild2 != NULL);
  assert(pChild2->getSibling() == NULL);

  // if one child is NaN, the result is NaN
  if ((CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::CONSTANT &&
       ((CEvaluationNodeConstant::SubType)(CEvaluationNode::subType(pChild1->getType()))) == CEvaluationNodeConstant::_NaN) ||
      (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::CONSTANT &&
       ((CEvaluationNodeConstant::SubType)(CEvaluationNode::subType(pChild2->getType()))) == CEvaluationNodeConstant::_NaN))
    {
      pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NAN");
    }
  // the second child is 0, the result is the first child
  else if ((CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER &&
            fabs(dynamic_cast<const CEvaluationNodeNumber*>(pChild2)->getValue()) < ZERO))
    {
      pResult = pChild1->copyBranch();
    }
  // if the first child is 0, the result is the second child
  else if ((CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::NUMBER &&
            fabs(dynamic_cast<const CEvaluationNodeNumber*>(pChild1)->getValue()) < ZERO))
    {
      pResult = pChild2->copyBranch();
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::elementaryEliminationPower ( const CEvaluationNode *  pPowerNode )

staticprotected

This method makes the elementary elimination on a power node.

This method makes the elementary elimination on a power node. This method makes the following elimination a) x^NaN -> NaN b) 0^0 -> NaN c) 0^(-x) -> NaN d) 0^x -> 0 e) 1^x -> 1 f) NaN^x -> NaN g) NFINITY^(-NaN) -> NaN i) INFINITY^-x -> 0.0 // x being a positive number j) INFINITY^x -> INFINITY // x being a positive number k) INFINITY^0 -> 1 l) INFINITY^0 -> 1.0 m) INFINITY^(-x) -> 0.0 n) INFINITY^x -> INFINITY o) INFINITY ^ x -> INFINITY p) x^0 -> 1 q) x^1 -> x

The caller is responsible for releasing the memory for the returned object.

Definition at line 787 of file CNormalTranslation.cpp.

References CEvaluationNodeConstant::_INFINITY, CEvaluationNodeConstant::_NaN, CEvaluationNode::CONSTANT, CEvaluationNode::copyBranch(), CEvaluationNodeNumber::DOUBLE, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNode::getValue(), CEvaluationNode::NUMBER, CEvaluationNode::OPERATOR, CEvaluationNodeOperator::POWER, pResult, CEvaluationNode::subType(), CEvaluationNode::type(), and ZERO.

Referenced by elementaryElimination().

{
  CEvaluationNode* pResult = NULL;
  assert(CEvaluationNode::type(pPowerNode->getType()) == CEvaluationNode::OPERATOR);
  assert(((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pPowerNode->getType())) == CEvaluationNodeOperator::POWER);
  const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(pPowerNode->getChild());
  assert(pChild1 != NULL);
  const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
  assert(pChild2 != NULL);
  assert(pChild2->getSibling() == NULL);

  if (CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::NUMBER)
    {
      // 0 and 1
      const CEvaluationNodeNumber* pNumberNode = dynamic_cast<const CEvaluationNodeNumber*>(pChild1);
      assert(pNumberNode != NULL);
      double value = pNumberNode->getValue();

      if (fabs(value) < ZERO)
        {
          // 0^(NaN) -> NaN
          if (pChild2->getType() == CEvaluationNode::CONSTANT && ((CEvaluationNodeConstant::SubType)CEvaluationNode::subType(pChild2->getType())) == CEvaluationNodeConstant::_NaN)
            {
              pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NaN");
            }
          else if (pChild2->getType() == CEvaluationNode::NUMBER)
            {
              const CEvaluationNodeNumber* pNumberNode2 = dynamic_cast<const CEvaluationNodeNumber*>(pChild2);
              double value = pNumberNode2->getValue();

              // 0^0 -> NaN
              // 0^(-x) -> NaN
              if (fabs(value) < ZERO || value < 0.0)
                {
                  pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NaN");
                }
            }

          // 0^x -> 0
          if (pResult == pPowerNode)
            {
              pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "0.0");
            }
        }
      else if (fabs(value - 1.0) < ZERO)
        {
          // 1^NaN -> NaN
          // 1^x -> 1
          if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::CONSTANT && ((CEvaluationNodeConstant::SubType)CEvaluationNode::subType(pChild2->getType())) == CEvaluationNodeConstant::_NaN)
            {
              pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NaN");
            }

          if (pResult == NULL)
            {
              pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0");
            }
        }

      /* ignore -1 for now
         else if(fabs(value + 1.0) < ZERO)
         {
         }
         */
    }
  else if (CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::CONSTANT)
    {
      // infinity and NaN
      if (((CEvaluationNodeConstant::SubType)CEvaluationNode::subType(pChild1->getType())) == CEvaluationNodeConstant::_NaN)
        {
          // NaN^x -> NaN
          pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NaN");
        }
      else if (((CEvaluationNodeConstant::SubType)CEvaluationNode::subType(pChild1->getType())) == CEvaluationNodeConstant::_INFINITY)
        {
          // INFINITY^(-NaN) -> NaN
          // INFINITY^-x -> 0.0 // x being a positive number
          // INFINITY^x -> INFINITY // x being a positive number
          // INFINITY^0 -> 1
          if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER)
            {
              const CEvaluationNodeNumber* pNumberNode2 = dynamic_cast<const CEvaluationNodeNumber*>(pChild2);
              assert(pNumberNode2 != NULL);
              double value = pNumberNode2->getValue();

              // INFINITY^0 -> 1
              if (fabs(value) < ZERO)
                {
                  pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0");
                }
              // INFINITY^x -> INFINITY // x being a positive number
              else if (value > 0.0)
                {
                  pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_INFINITY, "inf");
                }
              // INFINITY^-x -> 0.0 // x being a positive number
              else
                {
                  pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "0.0");
                }
            }
          else if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::CONSTANT && ((CEvaluationNodeConstant::SubType)CEvaluationNode::subType(pChild2->getType())) == CEvaluationNodeConstant::_NaN)
            {
              // INFINITY^NaN    -> NaN
              pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NaN");
            }
          /* the minus function is eliminated
          else if(CEvaluationNode::type(pChild2->getType())==CEvaluationNode::FUNCTION && ((CEvaluationNodeFunction::SubType)CEvaluationNode::subType(pChild2->getType()))==CEvaluationNodeFunction::MINUS)
          {
              CEvaluationNode* pChild=dynamic_cast<CEvaluationNode*>(pChild2->getChild());
              // INFINITY^(-CONSTANT) -> 0.0 // where CONSTANT != NaN
              if(CEvaluationNode::type(pChild->getType())==CEvaluationNode::CONSTANT)
              {
                  pResult=new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE,"0.0");
              }
          }
          */
          else if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER)
            {
              const CEvaluationNodeNumber* pNumberNode2 = dynamic_cast<const CEvaluationNodeNumber*>(pChild2);
              assert(pNumberNode2 != NULL);
              double value = pNumberNode2->getValue();

              // INFINITY^0 -> 1.0
              if (fabs(value) < ZERO)
                {
                  pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0");
                }
              // INFINITY^(-x) -> 0.0
              else if (value > 0.0)
                {
                  pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "0.0");
                }
              // INFINITY^x -> INFINITY
              else
                {
                  pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_INFINITY, "inf");
                }
            }

          // INFINITY ^ x -> INFINITY
          if (pResult == NULL)
            {
              pResult = new CEvaluationNodeConstant(CEvaluationNodeConstant::_INFINITY, "inf");
            }
        }
    }
  else if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER)
    {
      // 0 and 1
      const CEvaluationNodeNumber* pNumberNode2 = dynamic_cast<const CEvaluationNodeNumber*>(pChild2);
      assert(pNumberNode2 != NULL);
      double value = pNumberNode2->getValue();

      // x^0 -> 1.0
      if (fabs(value) < ZERO)
        {
          pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0");
        }
      else if (fabs(value - 1.0) < ZERO)
        {
          // make a deep copy of the first child
          pResult = pChild1->copyBranch();
        }

      /* ignore -1 since this may interfere with other simplification
       * mechanisms.
       * Negative exponents will be eliminated in the end.
       else if(fabs(value + 1.0) < ZERO)
       {
       }
       */
    }
  else if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::CONSTANT)
    {
      // infinity and NaN
      if (((CEvaluationNodeConstant::SubType)CEvaluationNode::subType(pChild2->getType())) == CEvaluationNodeConstant::_NaN)
        {
          pResult = pChild2->copyBranch();
        }
      else if (((CEvaluationNodeConstant::SubType)CEvaluationNode::subType(pChild2->getType())) == CEvaluationNodeConstant::_INFINITY)
        {
          pResult = pChild2->copyBranch();
        }
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::eliminate ( const CEvaluationNode *  pOrig )

staticprotected

This method elminates subexpressions from an expression

This method elminates subexpressions from an expression It calls: elementaryElimination eliminateNestedPowers eliminatePowersOfFractions eliminateDirectlyNestedFunctions cancel

These functions are called as long as the resulting tree contains changes

Definition at line 402 of file CNormalTranslation.cpp.

References CEvaluationNode::buildInfix(), CEvaluationNode::copyBranch(), elementaryElimination(), eliminateDirectlyNestedFractions(), eliminateNestedPowers(), eliminatePowersOfFractions(), newCancel(), and pResult.

Referenced by simplify().

{
  CEvaluationNode* pResult = pOrig->copyBranch();
  CEvaluationNode* pTmp = NULL;
  std::string infix = pResult->buildInfix(); //base->toString();
  //delete base;
  bool changed = true;

  while (changed)
    {
      // first make elementary eliminations
      pTmp = CNormalTranslation::elementaryElimination(pResult);

      if (pTmp != pResult) delete pResult;

      // now get rid of nested powers a^b^c
      pResult = CNormalTranslation::eliminateNestedPowers(pTmp);

      if (pResult != NULL)
        {
          delete pTmp;
          pTmp = pResult;
        }

      // eliminate fractions within powers
      // (a/b)^3 -> a^3 / b^3
      // now get rid of directly nested fractions
      pResult = CNormalTranslation::eliminatePowersOfFractions(pTmp);

      if (pResult != NULL)
        {
          delete pTmp;
          pTmp = pResult;
        }

      pResult = CNormalTranslation::eliminateDirectlyNestedFractions(pTmp);

      if (pResult != NULL)
        {
          delete pTmp;
        }
      else
        {
          pResult = pTmp;
        }

      // now cancel since cancelation can lead to new nodes for which
      // elementary elimination would be possible, we might have to run
      // this loop again
      pTmp = CNormalTranslation::newCancel(pResult);
      //std::cout << "Before:   " << pResult->buildInfix() << std::endl;


      if (pTmp != NULL)
        {
          delete pResult;
        }
      else
        {
          pTmp = pResult;
        }

      //std::cout << "Finished: " << pTmp->buildInfix() << std::endl;
      //delete pResult;

      // check if we are done
      // we are done if the infix has not changed over one loop run
      if (/*base->toString()*/pTmp->buildInfix() == infix)
        {
          changed = false;
        }
      else
        {
          infix = pTmp->buildInfix(); //base->toString();
        }

      pResult = pTmp;
      //delete base;
      //base = NULL;
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::eliminateDirectlyNestedFractions ( const CEvaluationNode *  pOrig )

staticprotected

This method eliminates directly nested fractions. ((a/b)/(c/d)) -> (a*d)/(b*c)

This method does all the canceling on a given node and its children. If no canceling was done, NULL is returned.

Obsolete recursive version This method does all the canceling on a given node and its children. CEvaluationNode* CNormalTranslation::cancel(const CEvaluationNode* pOrig) { TODO I think this method has much potential for improvement TODO since the comparison code seems to spend about 85% of the time TODO here, this is where I should start making optimizations

try to find multiplication chains where something is divided by itself or multiplied by -1 times itself also consider powers (it's the bases that have to match)

try to find addition changes where there is a subtraction of two identical nodes or an addition of one node and the same node times -1 CEvaluationNode* pResult = NULL; std::vector<CEvaluationNode*> children; std::cout << "Canceling: " << pOrig->buildInfix() << std::endl;

if (CEvaluationNode::type(pOrig->getType()) == CEvaluationNode::OPERATOR)
  {
    if (((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pOrig->getType())) == CEvaluationNodeOperator::PLUS ||
        ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pOrig->getType())) == CEvaluationNodeOperator::MINUS)
      {

we are in a sum std::vector<CEvaluationNode*> additions, subtractions; CNormalTranslation::splitSum(pOrig, additions, subtractions, false); CNormalTranslation::swapNegativeNumbers(additions, subtractions); collect all nodes in additions and subtractions unsigned int i, iMax = additions.size();

for (i = 0; i < iMax; ++i) { CEvaluationNode* pChild = CNormalTranslation::cancel(additions[i]); delete additions[i]; additions[i] = pChild; }

iMax = subtractions.size();

for (i = 0; i < iMax; ++i) { CEvaluationNode* pChild = CNormalTranslation::cancel(subtractions[i]); delete subtractions[i]; subtractions[i] = pChild; }

find identical nodes in additions and subtractions The first entry in the pair is the collected factor the second entry is the original branch make sure the collected factor is again simplified std::vector<std::pair<CEvaluationNode*, CEvaluationNode*> > collected = CNormalTranslation::matchSummands(additions, subtractions); iMax = additions.size();

for (i = 0; i < iMax; ++i) { delete additions[i]; }

additions.clear(); iMax = subtractions.size();

for (i = 0; i < iMax; ++i) { delete subtractions[i]; }

subtractions.clear(); std::vector<CEvaluationNode*> chain; iMax = collected.size();

for (i = 0; i < iMax; ++i) { std::pair<CEvaluationNode*, CEvaluationNode*> pair = collected[i];

CEvaluationNode* pTmpNode = CNormalTranslation::eliminate(pair.first); delete pair.first; if simplified node is 0.0, we ignore this node if (CEvaluationNode::type(pair.first->getType()) == CEvaluationNode::NUMBER && fabs(dynamic_cast<CEvaluationNodeNumber*>(pair.first)->getValue()) < ZERO) { delete pair.first; delete pair.second; } else if (CEvaluationNode::type(pair.first->getType()) == CEvaluationNode::NUMBER && fabs(dynamic_cast<CEvaluationNodeNumber*>(pair.first)->getValue() - 1.0) < ZERO) { delete pair.first; chain.push_back(pair.second); } else { CEvaluationNode* pMult = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*"); pMult->addChild(pair.first); pMult->addChild(pair.second); chain.push_back(pMult); } }

pResult = CNormalTranslation::createChain(&CNormalTranslation::PLUS_NODE, &CNormalTranslation::ZERO_NODE, chain); assert(pResult != NULL); } else if (((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pOrig->getType())) == CEvaluationNodeOperator::MULTIPLY || ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pOrig->getType())) == CEvaluationNodeOperator::DIVIDE) { we are in a product std::vector<const CEvaluationNode*> multiplications, divisions; CNormalTranslation::splitProduct(pOrig, multiplications, divisions, false); collect all nodes in multiplications and divisions unsigned int i, iMax = multiplications.size();

for (i = 0; i < iMax; ++i) { multiplications[i] = CNormalTranslation::cancel(multiplications[i]); }

iMax = divisions.size();

for (i = 0; i < iMax; ++i) { divisions[i] = CNormalTranslation::cancel(divisions[i]); }

find identical nodes in multiplications and divisions The first entry in the pair is the collected power exponent the second entry is the original power base make sure the collected factor is again simplified std::vector<std::pair<CEvaluationNode*, CEvaluationNode*> > collected = CNormalTranslation::matchPowerBases(multiplications, divisions); iMax = multiplications.size();

for (i = 0; i < iMax; ++i) { delete multiplications[i]; }

multiplications.clear(); iMax = divisions.size();

for (i = 0; i < iMax; ++i) { delete divisions[i]; }

divisions.clear(); std::vector<CEvaluationNode*> numeratorChain; std::vector<CEvaluationNode*> denominatorChain; iMax = collected.size();

for (i = 0; i < iMax; ++i) { std::pair<CEvaluationNode*, CEvaluationNode*> pair = collected[i];

CEvaluationNode* pTmpNode = CNormalTranslation::eliminate(pair.first); delete pair.first; if simplified node is a 0.0, we ignore this node if (CEvaluationNode::type(pair.first->getType()) == CEvaluationNode::NUMBER) { if (fabs(dynamic_cast<CEvaluationNodeNumber*>(pair.first)->getValue()) < ZERO) { delete pair.first; delete pair.second; } else if (dynamic_cast<CEvaluationNodeNumber*>(pair.first)->getValue() > 0.0) { if (fabs(dynamic_cast<CEvaluationNodeNumber*>(pair.first)->getValue() - 1.0) < ZERO) { delete pair.first; numeratorChain.push_back(pair.second); } else { CEvaluationNode* pPower = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^"); pPower->addChild(pair.second); pPower->addChild(pair.first); numeratorChain.push_back(pPower); } } else { if (fabs(dynamic_cast<CEvaluationNodeNumber*>(pair.first)->getValue() + 1.0) < ZERO) { delete pair.first; denominatorChain.push_back(pair.second); } else { CEvaluationNode* pPower = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^"); pPower->addChild(pair.second); std::ostringstream os; os.precision(18); os << fabs(dynamic_cast<const CEvaluationNodeNumber*>(pair.first)->getValue()); pPower->addChild(new CEvaluationNodeNumber((CEvaluationNodeNumber::SubType)CEvaluationNode::subType(pair.first->getType()), os.str().c_str())); delete pair.first; denominatorChain.push_back(pPower); } } } else { CEvaluationNode* pPower = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");

check if the node is -1.0 * SOMETHING if (CEvaluationNode::type(pair.first->getType()) == CEvaluationNode::OPERATOR && (CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pair.first->getType()) == CEvaluationNodeOperator::MULTIPLY && CEvaluationNode::type(dynamic_cast<const CEvaluationNode*>(pair.first->getChild())->getType()) == CEvaluationNode::NUMBER) { if (fabs(static_cast<const CEvaluationNodeNumber*>(pair.first->getChild())->getValue() + 1.0) < ZERO) { pPower->addChild(pair.second); pPower->addChild(dynamic_cast<const CEvaluationNode*>(pair.first->getChild()->getSibling())->copyBranch()); delete pair.first; denominatorChain.push_back(pPower); } else if (fabs(static_cast<const CEvaluationNodeNumber*>(pair.first->getChild())->getValue()) < ZERO) { delete the power node and add delete pPower; delete pair.first; numeratorChain.push_back(pair.second); } else if (static_cast<const CEvaluationNodeNumber*>(pair.first->getChild())->getValue() < 0.0) { pPower->addChild(pair.second); pPower->addChild(pair.first); denominatorChain.push_back(pPower); } else { pPower->addChild(pair.second); pPower->addChild(pair.first); numeratorChain.push_back(pPower); } } else { pPower->addChild(pair.second); pPower->addChild(pair.first); numeratorChain.push_back(pPower); } } }

if there are only divisions, we have an empty numerator chain if (numeratorChain.empty()) { pResult = CNormalTranslation::ONE_NODE.copyBranch(); } else { pResult = CNormalTranslation::createChain(&CNormalTranslation::TIMES_NODE, &CNormalTranslation::ONE_NODE, numeratorChain); assert(pResult != NULL); }

if (!denominatorChain.empty()) { CEvaluationNode* pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE, "/"); pTmpNode->addChild(pResult); pResult = pTmpNode; pTmpNode = CNormalTranslation::createChain(&CNormalTranslation::TIMES_NODE, &CNormalTranslation::ONE_NODE, denominatorChain); assert(pTmpNode != NULL); pResult->addChild(pTmpNode); } } else { const CEvaluationNode* pChild = dynamic_cast<const CEvaluationNode*>(pOrig->getChild());

while (pChild != NULL) { children.push_back(CNormalTranslation::cancel(pChild)); pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling()); }

assert(children.size() == 2); } } else { const CEvaluationNode* pChild = dynamic_cast<const CEvaluationNode*>(pOrig->getChild());

while (pChild != NULL) { children.push_back(CNormalTranslation::cancel(pChild)); pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling()); } }

if (pResult == NULL) { pResult = pOrig->copyNode(children); }

if(pOrig->buildInfix() == pResult->buildInfix()) { std::cout << "Nothing Canceled." << std::endl; } else { std::cout << "Canceled: " << pResult->buildInfix() << std::endl; } return pResult; } This method eliminates directly nested fractions. A/B/C -> A/(B*C)

The caller is responsible for deleting the returned object.

Definition at line 5121 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNode::copyBranch(), CEvaluationNode::copyNode(), CEvaluationNodeOperator::DIVIDE, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNodeOperator::MULTIPLY, CEvaluationNode::OPERATOR, pResult, CCopasiNode< _Data >::removeChild(), CEvaluationNode::subType(), and CEvaluationNode::type().

Referenced by eliminate().

{
  if (pOrig == NULL) return NULL;

  CEvaluationNode* pResult = NULL;
  std::vector<CEvaluationNode*> children;
  const CEvaluationNode* pChild = dynamic_cast<const CEvaluationNode*>(pOrig->getChild());
  CEvaluationNode* pNewChild = NULL;
  const CEvaluationNode* pTmpOrig = pOrig;
  bool childrenChanged = false;

  while (pChild != NULL)
    {
      pNewChild = CNormalTranslation::eliminateDirectlyNestedFractions(pChild);

      if (pNewChild != NULL)
        {
          childrenChanged = true;
        }

      children.push_back(pNewChild);
      pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling());
    }

  if (childrenChanged == true)
    {
      std::vector<CEvaluationNode*>::iterator it = children.begin(), endit = children.end();
      pChild = dynamic_cast<const CEvaluationNode*>(pTmpOrig->getChild());

      while (it != endit)
        {
          if ((*it) == NULL)
            {
              (*it) = pChild->copyBranch();
            }

          pChild = static_cast<const CEvaluationNode*>(pChild->getSibling());
          ++it;
        }

      assert(pChild == NULL);
      // make a copy of the original with the new children
      pResult = pTmpOrig->copyNode(children);
      pTmpOrig = pResult;
    }


  if (CEvaluationNode::type(pTmpOrig->getType()) == CEvaluationNode::OPERATOR && (CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pOrig->getType()) == CEvaluationNodeOperator::DIVIDE)
    {
      // check if one of the children (or both) are a division
      const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(pTmpOrig->getChild());
      assert(pChild1 != NULL);
      const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
      assert(pChild2 != NULL);
      assert(pChild2->getSibling() == NULL);

      if (CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::OPERATOR && (CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pChild1->getType()) == CEvaluationNodeOperator::DIVIDE)
        {
          if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::OPERATOR && (CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pChild2->getType()) == CEvaluationNodeOperator::DIVIDE)
            {
              // both children are division
              CEvaluationNode* pTmpResult = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE, "/");
              CEvaluationNode* pTmp = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
              pTmp->addChild(dynamic_cast<const CEvaluationNode*>(pChild1->getChild())->copyBranch());
              pTmp->addChild(dynamic_cast<const CEvaluationNode*>(pChild2->getChild()->getSibling())->copyBranch());
              pTmpResult->addChild(pTmp);
              pTmp = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
              pTmp->addChild(dynamic_cast<const CEvaluationNode*>(pChild1->getChild()->getSibling())->copyBranch());
              pTmp->addChild(dynamic_cast<const CEvaluationNode*>(pChild2->getChild())->copyBranch());
              pTmpResult->addChild(pTmp);

              if (pResult != NULL)
                {
                  delete pResult;
                }

              pResult = pTmpResult;
            }
          else
            {
              // only the first child is a division
              CEvaluationNode* pTmpResult = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE, "/");
              pTmpResult->addChild(dynamic_cast<const CEvaluationNode*>(pChild1->getChild())->copyBranch());
              CEvaluationNode* pTmp = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
              pTmp->addChild(dynamic_cast<const CEvaluationNode*>(pChild1->getChild()->getSibling())->copyBranch());

              if (pResult == NULL)
                {
                  pTmp->addChild(pChild2->copyBranch());
                }
              else
                {
                  assert(pResult == pTmpOrig);
                  pResult->removeChild(const_cast<CEvaluationNode*>(pChild2));
                  pTmp->addChild(const_cast<CEvaluationNode*>(pChild2));
                  delete pResult;
                }

              pTmpResult->addChild(pTmp);
              pResult = pTmpResult;
            }
        }
      else if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::OPERATOR && (CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pChild2->getType()) == CEvaluationNodeOperator::DIVIDE)
        {
          // only the second child is a division
          CEvaluationNode* pTmpResult = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE, "/");
          CEvaluationNode* pTmp = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");

          if (pResult != NULL)
            {
              assert(pTmpOrig == pResult);
              pResult->removeChild(const_cast<CEvaluationNode*>(pChild1));
              pTmp->addChild(const_cast<CEvaluationNode*>(pChild1));
            }
          else
            {
              pTmp->addChild(pChild1->copyBranch());
            }

          pTmp->addChild(dynamic_cast<const CEvaluationNode*>(pChild2->getChild()->getSibling())->copyBranch());
          pTmpResult->addChild(pTmp);
          pTmpResult->addChild(dynamic_cast<const CEvaluationNode*>(pChild2->getChild())->copyBranch());

          if (pResult != NULL)
            {
              delete pResult;
            }

          pResult = pTmpResult;
        }
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::eliminateNestedPowers ( const CEvaluationNode *  pOrig )

staticprotected

This method removes nested power nodes, e.g. (a^b)^c -> a^(b*c)

This method removes nested power nodes, e.g. (a^b)^c -> a^(b*c)

The caller is responsible for freeing the memory of the returned object.

Definition at line 2286 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNode::copyBranch(), CEvaluationNode::copyNode(), CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNodeOperator::MULTIPLY, CEvaluationNode::OPERATOR, CEvaluationNodeOperator::POWER, pResult, CCopasiNode< _Data >::removeChild(), CEvaluationNode::subType(), and CEvaluationNode::type().

Referenced by eliminate().

{
  CEvaluationNode* pResult = NULL;
  std::vector<CEvaluationNode*> children;
  const CEvaluationNode* pTmpOrig = pOrig;
  const CEvaluationNode* pChild = dynamic_cast<const CEvaluationNode*>(pTmpOrig->getChild());
  bool childrenChanged = false;
  CEvaluationNode* pNewChild = NULL;

  while (pChild != NULL)
    {
      pNewChild = CNormalTranslation::eliminateNestedPowers(pChild);

      if (pNewChild != NULL)
        {
          childrenChanged = true;
        }

      children.push_back(pNewChild);
      pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling());
    }

  if (childrenChanged == true)
    {
      std::vector<CEvaluationNode*>::iterator it = children.begin(), endit = children.end();
      pChild = static_cast<const CEvaluationNode*>(pTmpOrig->getChild());

      while (it != endit)
        {
          if ((*it) == NULL)
            {
              (*it) = pChild->copyBranch();
            }

          pChild = static_cast<const CEvaluationNode*>(pChild->getSibling());
          ++it;
        }

      assert(pChild == NULL);
      pResult = pTmpOrig->copyNode(children);
      pTmpOrig = pResult;
    }

  if (CEvaluationNode::type(pTmpOrig->getType()) == CEvaluationNode::OPERATOR &&
      ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pTmpOrig->getType())) == CEvaluationNodeOperator::POWER)
    {
      // check if the first child is also a power node
      const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(pTmpOrig->getChild());
      assert(pChild1 != NULL);
      const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
      assert(pChild2 != NULL);
      assert(pChild2->getSibling() == NULL);

      if (CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::OPERATOR &&
          ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pChild1->getType())) == CEvaluationNodeOperator::POWER)
        {
          CEvaluationNode* pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");
          const CEvaluationNode* pChild = dynamic_cast<const CEvaluationNode*>(pChild1->getChild());
          assert(pChild != NULL);
          pTmpNode->addChild(pChild->copyBranch());
          CEvaluationNode* pMult = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
          pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling());
          assert(pChild != NULL);
          pMult->addChild(pChild->copyBranch());

          if (pResult == NULL)
            {
              pMult->addChild(pChild2->copyBranch());
            }
          else
            {
              assert(pResult == pTmpOrig);
              pResult->removeChild(const_cast<CEvaluationNode*>(pChild2));
              pMult->addChild(const_cast<CEvaluationNode*>(pChild2));
              delete pResult;
            }

          pTmpNode->addChild(pMult);
          pResult = pTmpNode;
        }
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::eliminatePowersOfFractions ( const CEvaluationNode *  pOrig )

staticprotected

This method gets rid of fractions within a power construct. (a/b)^3 -> a^3 / b^3

This method replaces a power of a fraction by the fraction of two power nodes. (A/B)^x -> A^x / B^x

The caller is responsible for deleting the returned object.

Definition at line 5263 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNode::copyBranch(), CEvaluationNode::copyNode(), CEvaluationNodeOperator::DIVIDE, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNode::OPERATOR, CEvaluationNodeOperator::POWER, pResult, CCopasiNode< _Data >::removeChild(), CEvaluationNode::subType(), and CEvaluationNode::type().

Referenced by eliminate().

{
  if (pOrig == NULL) return NULL;

  CEvaluationNode* pResult = NULL;

  std::vector<CEvaluationNode*> children;
  const CEvaluationNode* pChild = dynamic_cast<const CEvaluationNode*>(pOrig->getChild());
  CEvaluationNode* pNewChild = NULL;
  const CEvaluationNode* pTmpOrig = pOrig;
  bool childrenChanged = false;

  while (pChild != NULL)
    {
      pNewChild = CNormalTranslation::eliminatePowersOfFractions(pChild);

      if (pNewChild != NULL)
        {
          childrenChanged = true;
        }

      children.push_back(pNewChild);
      pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling());
    }

  if (childrenChanged == true)
    {
      pChild = dynamic_cast<const CEvaluationNode*>(pTmpOrig->getChild());
      std::vector<CEvaluationNode*>::iterator it = children.begin(), endit = children.end();

      while (it != endit)
        {
          if ((*it) == NULL)
            {
              (*it) = pChild->copyBranch();
            }

          pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling());
          ++it;
        }

      assert(pChild == NULL);
      pResult = pTmpOrig->copyNode(children);
      pTmpOrig = pResult;
    }

  if (CEvaluationNode::type(pTmpOrig->getType()) == CEvaluationNode::OPERATOR && (CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pOrig->getType()) == CEvaluationNodeOperator::POWER)
    {
      const CEvaluationNode* pChild1 = static_cast<const CEvaluationNode*>(pTmpOrig->getChild());
      assert(pChild1 != NULL);
      const CEvaluationNode* pChild2 = static_cast<const CEvaluationNode*>(pChild1->getSibling());
      assert(pChild2 != NULL);
      assert(pChild2->getSibling() == NULL);

      if (CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::OPERATOR && (CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pChild1->getType()) == CEvaluationNodeOperator::DIVIDE)
        {
          // the first child is a division

          CEvaluationNode* pTmpResult = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE, "/");
          CEvaluationNode* pTmp = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");
          pTmp->addChild(dynamic_cast<const CEvaluationNode*>(pChild1->getChild())->copyBranch());
          pTmp->addChild(pChild2->copyBranch());
          pTmpResult->addChild(pTmp);
          pTmp = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");
          pTmp->addChild(dynamic_cast<const CEvaluationNode*>(pChild1->getChild()->getSibling())->copyBranch());

          if (pResult == NULL)
            {
              pTmp->addChild(pChild2->copyBranch());
            }
          else
            {
              // since pResult is a new object, we can safely modify it
              pResult->removeChild(const_cast<CEvaluationNode*>(pChild2));
              pTmp->addChild(const_cast<CEvaluationNode*>(pChild2));
              delete pResult;
            }

          pTmpResult->addChild(pTmp);
          pResult = pTmpResult;
        }
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::expandPowerBases ( const CEvaluationNode *  pRoot )

static

Given a root node, this method traverses the tree and expands products in power bases to multiplications of power items. It is the responsibility of the caller to delete the returned node.

Given a root node, this method traverses the tree and expands produtcs in power bases to multiplications of power items.

(A*B)^x -> A^x * B^x

It is the responsibility of the caller to delete the returned node if it is not NULL.

Definition at line 5444 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNode::copyBranch(), CEvaluationNode::copyNode(), createChain(), CEvaluationNodeOperator::DIVIDE, factorize(), CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNodeOperator::MINUS, CEvaluationNodeOperator::MULTIPLY, CEvaluationNode::OPERATOR, CEvaluationNodeOperator::PLUS, CEvaluationNodeOperator::POWER, pResult, CCopasiNode< _Data >::removeChild(), splitProduct(), splitSum(), CEvaluationNode::subType(), swapNegativeNumbers(), and CEvaluationNode::type().

Referenced by simplify().

{
  CEvaluationNode* pResult = NULL;
  std::vector<CEvaluationNode*> children;

  const CEvaluationNode* pChild = dynamic_cast<const CEvaluationNode*>(pRoot->getChild());
  CEvaluationNode* pNewChild = NULL;
  bool childrenChanged = false;

  while (pChild != NULL)
    {
      pNewChild = CNormalTranslation::expandPowerBases(pChild);

      if (pNewChild != NULL)
        {
          childrenChanged = true;
        }

      children.push_back(pNewChild);
      pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling());
    }

  if (childrenChanged == true)
    {
      std::vector<CEvaluationNode*>::iterator it = children.begin(), endit = children.end();
      pChild = dynamic_cast<const CEvaluationNode*>(pRoot->getChild());

      while (it != endit)
        {
          if ((*it) == NULL)
            {
              (*it) = pChild->copyBranch();
            }

          pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling());
          ++it;
        }

      assert(pChild == NULL);
    }

  pResult = pRoot->copyNode(children);
  pRoot = pResult;


  CEvaluationNode::Type type = pRoot->getType();

  if (CEvaluationNode::type(type) == CEvaluationNode::OPERATOR && (CEvaluationNodeOperator::SubType)CEvaluationNode::subType(type) == CEvaluationNodeOperator::POWER)
    {
      const CEvaluationNode* pBase = dynamic_cast<const CEvaluationNode*>(pRoot->getChild());
      assert(pBase != NULL);
      const CEvaluationNode* pExp = dynamic_cast<const CEvaluationNode*>(pBase->getSibling());
      assert(pExp != NULL);
      type = pBase->getType();

      if (CEvaluationNode::type(type) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(type) == CEvaluationNodeOperator::MULTIPLY || (CEvaluationNodeOperator::SubType)CEvaluationNode::subType(type) == CEvaluationNodeOperator::DIVIDE))
        {
          std::vector<const CEvaluationNode*> multiplications, divisions;
          std::vector<CEvaluationNode*> numeratorNodes, denominatorNodes;
          CNormalTranslation::splitProduct(pBase, multiplications, divisions, false);

          std::vector<const CEvaluationNode*>::const_iterator it = multiplications.begin(), endit = multiplications.end();
          CEvaluationNode* pPower = NULL;

          while (it != endit)
            {
              pPower = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");

              if (pResult == NULL)
                {
                  pPower->addChild((*it)->copyBranch());
                }
              else
                {
                  // since pResult is a new node and not the original,
                  // we can safely modify it instead of copying a whole branch
                  if ((*it)->getParent() != NULL)
                    {
                      const_cast<CEvaluationNode*>((*it))->getParent()->removeChild(const_cast<CEvaluationNode*>(*it));
                    }

                  pPower->addChild(const_cast<CEvaluationNode*>(*it));
                }

              pPower->addChild(pExp->copyBranch());
              numeratorNodes.push_back(pPower);
              ++it;
            }

          CEvaluationNode* pTmp = CNormalTranslation::createChain(&CNormalTranslation::TIMES_NODE, &CNormalTranslation::ONE_NODE, numeratorNodes);
          assert(pTmp != NULL);

          if (!divisions.empty())
            {
              it = divisions.begin(), endit = divisions.end();

              while (it != endit)
                {
                  pPower = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");

                  if (pResult == NULL)
                    {
                      pPower->addChild((*it)->copyBranch());
                    }
                  else
                    {
                      // since pResult is a new node and not the original,
                      // we can safely modify it instead of copying a whole branch
                      if ((*it)->getParent() != NULL)
                        {
                          const_cast<CEvaluationNode*>((*it))->getParent()->removeChild(const_cast<CEvaluationNode*>(*it));
                        }

                      pPower->addChild(const_cast<CEvaluationNode*>(*it));
                    }

                  pPower->addChild(pExp->copyBranch());
                  denominatorNodes.push_back(pPower);
                  ++it;
                }

              CEvaluationNode* pTmpResult = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE, "/");
              pTmpResult->addChild(pTmp);
              pTmp = CNormalTranslation::createChain(&CNormalTranslation::TIMES_NODE, &CNormalTranslation::ONE_NODE, denominatorNodes);
              assert(pTmp != NULL);
              pTmpResult->addChild(pTmp);
              pTmp = pTmpResult;
            }

          if (pResult != NULL)
            {
              delete pResult;
            }

          pResult = pTmp;
        }
      else if (CEvaluationNode::type(type) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(type) == CEvaluationNodeOperator::PLUS || (CEvaluationNodeOperator::SubType)CEvaluationNode::subType(type) == CEvaluationNodeOperator::MINUS))
        {
          std::vector<CEvaluationNode*> additions, subtractions;
          CNormalTranslation::splitSum(pBase, additions, subtractions, false);
          CNormalTranslation::swapNegativeNumbers(additions, subtractions);
          std::pair<CEvaluationNode*, CEvaluationNode*> resultPair = CNormalTranslation::factorize(additions, subtractions);
          unsigned int i, iMax = additions.size();

          for (i = 0; i < iMax; ++i)
            {
              delete additions[i];
            }

          additions.clear();
          iMax = subtractions.size();

          for (i = 0; i < iMax; ++i)
            {
              delete subtractions[i];
            }

          subtractions.clear();

          if (resultPair.first != NULL)
            {
              CEvaluationNode* pTmp = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
              CEvaluationNode* pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");
              pTmpNode->addChild(resultPair.first);
              pTmpNode->addChild(pExp->copyBranch());
              pTmp->addChild(pTmpNode);
              pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");
              pTmpNode->addChild(resultPair.second);
              pTmpNode->addChild(pExp->copyBranch());
              pTmp->addChild(pTmpNode);

              if (pResult != NULL)
                {
                  delete pResult;
                }

              pResult = pTmp;
            }
        }
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::expandPowerExponents ( const CEvaluationNode *  pRoot )

static

Given a root node, this method traverses the tree and expands sums in power exponents to multiplications of power items. It is the responsibility of the caller to delete the returned node.

Takes a node and expands expressions like x^(n+m) to x^n * x^m If some of the exponent summands are negative numbers, the expression is divided by the positive exponent expression (x^(n-5) -> x^n / x^5

Definition at line 197 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNode::create(), createChain(), CEvaluationNodeOperator::DIVIDE, CEvaluationNodeNumber::DOUBLE, findSummands(), CEvaluationNode::FUNCTION, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getData(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNodeFunction::MINUS, CEvaluationNode::NUMBER, CEvaluationNode::OPERATOR, CEvaluationNodeOperator::POWER, pResult, CEvaluationNode::subType(), and CEvaluationNode::type().

Referenced by normAndSimplify().

{
  CEvaluationNode* pResult = NULL;
  const CEvaluationNode* pChild = dynamic_cast<const CEvaluationNode*>(pRoot->getChild());
  std::vector<CEvaluationNode*> children;

  // go through this depth first and expand the power exponents in children
  while (pChild != NULL)
    {
      CEvaluationNode* pNewChild = CNormalTranslation::expandPowerExponents(pChild);
      children.push_back(pNewChild);
      pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling());
    }

  if (CEvaluationNode::type(pRoot->getType()) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pRoot->getType())) == CEvaluationNodeOperator::POWER)
    {
      assert(children.size() == 2);
      std::vector<const CEvaluationNode*> summands;
      CNormalTranslation::findSummands(children[1], summands);
      // for each summand create a power node with a copy of the first child
      // in children as child 1 and a copy of the summand as child 2
      std::vector<CEvaluationNode*> numeratorNodes;
      std::vector<CEvaluationNode*> denominatorNodes;
      std::vector<const CEvaluationNode*>::iterator it = summands.begin(), endit = summands.end();

      while (it != endit)
        {
          CEvaluationNodeOperator* pPowerNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");
          pPowerNode->addChild(children[0]->copyBranch());

          if (CEvaluationNode::type((*it)->getType()) == CEvaluationNode::FUNCTION && ((CEvaluationNodeFunction::SubType)CEvaluationNode::subType((*it)->getType())) == CEvaluationNodeFunction::MINUS)
            {
              pPowerNode->addChild(dynamic_cast<const CEvaluationNode*>((*it)->getChild())->copyBranch());
              denominatorNodes.push_back(pPowerNode);
            }
          else if ((CEvaluationNode::type((*it)->getType()) == CEvaluationNode::NUMBER && dynamic_cast<const CEvaluationNodeNumber*>((*it))->getValue() < 0.0))
            {
              std::ostringstream os;
              os.precision(18);
              os << fabs(dynamic_cast<const CEvaluationNodeNumber*>(*it)->getValue());
              pPowerNode->addChild(new CEvaluationNodeNumber((CEvaluationNodeNumber::SubType)CEvaluationNode::subType((*it)->getType()), os.str().c_str()));
              denominatorNodes.push_back(pPowerNode);
            }
          else
            {
              pPowerNode->addChild((*it)->copyBranch());
              numeratorNodes.push_back(pPowerNode);
            }

          ++it;
        }

      delete children[0];
      delete children[1];

      // create the numerator chain
      if (numeratorNodes.empty())
        {
          pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0");
        }
      else
        {
          pResult = CNormalTranslation::createChain(&CNormalTranslation::TIMES_NODE, &CNormalTranslation::ONE_NODE, numeratorNodes);
        }

      assert(pResult != NULL);

      // if there are items in the denominator vector create the denominator
      // chain and divide the numerator chain by the denominator chain
      if (!denominatorNodes.empty())
        {
          CEvaluationNodeOperator* pDivision = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE, "/");
          pDivision->addChild(pResult);
          pDivision->addChild(CNormalTranslation::createChain(&CNormalTranslation::TIMES_NODE, &CNormalTranslation::ONE_NODE, denominatorNodes));
          pResult = pDivision;
        }
    }
  else
    {
      // copy the node and add the children
      pResult = CEvaluationNode::create(pRoot->getType(), pRoot->getData());
      std::vector<CEvaluationNode*>::iterator it = children.begin(), endit = children.end();

      while (it != endit)
        {
          pResult->addChild(*it);
          ++it;
        }
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::expandPowerNodes ( const CEvaluationNode *  pOrig )

staticprotected

This method expands the exponents of power nodes, e.g. A^(x+y) -> A^x * A^y

This method expands the exponents of power nodes, e.g. A^(x+y) -> A^x * A^y

The caller is responsible for freeing the memory of the returned object if it is not NULL.

Definition at line 2766 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNode::copyBranch(), CEvaluationNode::copyNode(), createChain(), CEvaluationNodeOperator::DIVIDE, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNode::NUMBER, CEvaluationNode::OPERATOR, CEvaluationNodeOperator::POWER, pResult, splitSum(), CEvaluationNode::subType(), swapNegativeNumbers(), and CEvaluationNode::type().

Referenced by simplify().

{
  CEvaluationNode* pResult = NULL;
  std::vector<CEvaluationNode*> children;
  const CEvaluationNode* pChild = dynamic_cast<const CEvaluationNode*>(pOrig->getChild());
  CEvaluationNode* pNewChild = NULL;
  const CEvaluationNode* pTmpOrig = pOrig;
  bool childrenChanged = false;

  while (pChild != NULL)
    {
      pNewChild = CNormalTranslation::expandPowerNodes(pChild);

      if (pNewChild != NULL)
        {
          childrenChanged = true;
        }

      children.push_back(pNewChild);
      pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling());
    }

  if (childrenChanged == true)
    {
      pChild = dynamic_cast<const CEvaluationNode*>(pTmpOrig->getChild());
      std::vector<CEvaluationNode*>::iterator it = children.begin(), endit = children.end();

      while (it != endit)
        {
          if ((*it) == NULL)
            {
              (*it) = pChild->copyBranch();
            }

          pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling());
          ++it;
        }

      pResult = pTmpOrig->copyNode(children);
      pTmpOrig = pResult;
    }


  if (CEvaluationNode::type(pTmpOrig->getType()) == CEvaluationNode::OPERATOR &&
      ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pTmpOrig->getType())) == CEvaluationNodeOperator::POWER)
    {
      const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(pTmpOrig->getChild());
      assert(pChild1 != NULL);
      const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
      assert(pChild2 != NULL);
      assert(pChild2->getSibling() == NULL);

      std::vector<CEvaluationNode*> additions, subtractions;
      CNormalTranslation::splitSum(pChild2, additions, subtractions, false);
      CNormalTranslation::swapNegativeNumbers(additions, subtractions);

      // the root node is a fraction
      // the denominator is a product of all subtraction nodes
      // the numerator is a product of all addition nodes
      if (!additions.empty() || !subtractions.empty())
        {
          // replace all nodes in additions and subtractions by
          // pChild1^node so we can use the generic method to create the
          // multiplication chain
          unsigned int i, iMax = additions.size();

          for (i = 0; i < iMax; ++i)
            {
              CEvaluationNode* pTmpNode = NULL;

              if (CEvaluationNode::type(additions[i]->getType()) == CEvaluationNode::NUMBER && fabs(static_cast<const CEvaluationNodeNumber*>(additions[i])->getValue() - 1.0) < 1e-12)
                {
                  delete additions[i];
                  pTmpNode = pChild1->copyBranch();
                }
              else
                {
                  pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");
                  pTmpNode->addChild(pChild1->copyBranch());
                  // don't copy additions element since this has been created in
                  // splitSum
                  pTmpNode->addChild(additions[i]);
                  additions[i] = pTmpNode;
                }

              additions[i] = pTmpNode;
            }

          iMax = subtractions.size();

          for (i = 0; i < iMax; ++i)
            {
              CEvaluationNode* pTmpNode = NULL;

              if (CEvaluationNode::type(subtractions[i]->getType()) == CEvaluationNode::NUMBER && fabs(static_cast<const CEvaluationNodeNumber*>(subtractions[i])->getValue() - 1.0) < 1e-12)
                {
                  pTmpNode = pChild1->copyBranch();
                  delete subtractions[i];
                }
              else
                {
                  pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");
                  pTmpNode->addChild(pChild1->copyBranch());
                  // don't copy subtractions element since this has been created in
                  // splitSum
                  pTmpNode->addChild(subtractions[i]);
                }

              subtractions[i] = pTmpNode;
            }

          // if we have only subtractions, the numerator of the resulting
          // exponent has to be 1
          CEvaluationNode* pTmpResult = NULL;

          if (additions.empty())
            {
              pTmpResult = CNormalTranslation::ONE_NODE.copyBranch();
            }
          else
            {
              pTmpResult = CNormalTranslation::createChain(&CNormalTranslation::TIMES_NODE, &CNormalTranslation::ONE_NODE, additions);
              additions.clear();
            }

          assert(pTmpResult != NULL);

          if (!subtractions.empty())
            {
              CEvaluationNode* pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE, "/");
              pTmpNode->addChild(pTmpResult);
              pTmpResult = pTmpNode;
              pTmpNode = CNormalTranslation::createChain(&CNormalTranslation::TIMES_NODE, &CNormalTranslation::ONE_NODE, subtractions);
              assert(pTmpNode != NULL);
              pTmpResult->addChild(pTmpNode);
              subtractions.clear();
            }

          if (pResult != NULL)
            {
              delete pResult;
            }

          pResult = pTmpResult;
        }
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::expandProducts ( const CEvaluationNode *  pOrig )

static

This method expands products. (A+B)*(C+D) -> (A*C)+(A*D)+(B*C)+(B*D) This method should be replaced by the one below pretty soon.

This method expands products. (A+B)*(C+D) -> (A*C)+(A*D)+(B*C)+(B*D)

Definition at line 3835 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNode::copyNode(), CEvaluationNodeOperator::DIVIDE, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNodeOperator::MULTIPLY, multiply(), CEvaluationNode::OPERATOR, pResult, splitProduct(), CEvaluationNode::subType(), and CEvaluationNode::type().

Referenced by createNormalRepresentation(), and simplify().

{
  CEvaluationNode* pResult = NULL;

  // we have to create operation chains and do the multiplication
  // on the numerator and the denominator chain if the node is a multiplication
  // or a division
  if (CEvaluationNode::type(pOrig->getType()) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pOrig->getType()) == CEvaluationNodeOperator::MULTIPLY || (CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pOrig->getType()) == CEvaluationNodeOperator::DIVIDE))
    {
      std::vector<const CEvaluationNode*> multiplications, divisions;
      CNormalTranslation::splitProduct(pOrig, multiplications, divisions, false);
      unsigned int i, iMax = multiplications.size();
      CEvaluationNode* pTmpResult;

      for (i = 0; i < iMax; ++i)
        {
          if (pResult == NULL)
            {
              pResult = CNormalTranslation::expandProducts(multiplications[i]);
            }
          else
            {
              CEvaluationNode* pTmpNode = CNormalTranslation::expandProducts(multiplications[i]);
              pTmpResult = CNormalTranslation::multiply(pResult, pTmpNode);
              delete pResult;
              delete pTmpNode;
              pResult = pTmpResult;
            }
        }

      if (!divisions.empty())
        {
          CEvaluationNode* pDenominator = NULL;
          iMax = divisions.size();

          for (i = 0; i < iMax; ++i)
            {
              if (pDenominator == NULL)
                {
                  pDenominator = CNormalTranslation::expandProducts(divisions[i]);
                }
              else
                {
                  CEvaluationNode* pTmpNode = CNormalTranslation::expandProducts(divisions[i]);
                  pTmpResult = CNormalTranslation::multiply(pDenominator, pTmpNode);
                  delete pDenominator;
                  delete pTmpNode;
                  pDenominator = pTmpResult;
                }

              //delete divisions[i];
            }

          pTmpResult = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE, "/");
          pTmpResult->addChild(pResult);
          pTmpResult->addChild(pDenominator);
          pResult = pTmpResult;
        }
    }
  else
    {
      const CEvaluationNode* pChild = dynamic_cast<const CEvaluationNode*>(pOrig->getChild());
      std::vector<CEvaluationNode*> children;

      while (pChild != NULL)
        {
          children.push_back(CNormalTranslation::expandProducts(pChild));
          pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling());
        }

      if (CEvaluationNode::type(pOrig->getType()) == CEvaluationNode::OPERATOR &&
          ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pOrig->getType())) == CEvaluationNodeOperator::MULTIPLY)
        {
          assert(children.size() == 2);
          pResult = CNormalTranslation::multiply(children[0], children[1]);
          // delete the children
          delete children[0];
          delete children[1];
        }

      if (pResult == NULL)
        {
          pResult = pOrig->copyNode(children);
        }
    }

  return pResult;
}

std::pair< CEvaluationNode *, CEvaluationNode * > CNormalTranslation::factorize ( const std::vector< CEvaluationNode * > &  additions, const std::vector< CEvaluationNode * > &  subtractions  )

staticprotected

This method takes two vectors. One with a list of nodes that are added and one with nodes that are subtracted. It tries to find common factors and divisors in those nodes and returns two result nodes. The first is the multiplication of all common factors and divisors, the other is the sum of the remaining additions and subtractions after removing the common factors and divisors. e.g. (A*B*D+A*C*D) -> returns (A*D) and (B+C)

This method takes two vectors and checks if the elements in the two vectors can be split into multiplications and divisions and if there a common factors in all resulting subgroups.

Definition at line 5632 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), createChain(), createOperatorChain(), CEvaluationNodeOperator::DIVIDE, CEvaluationNode::getType(), CEvaluationNodeOperator::MINUS, CEvaluationNodeOperator::MULTIPLY, CEvaluationNode::OPERATOR, splitProduct(), CEvaluationNode::subType(), and CEvaluationNode::type().

Referenced by expandPowerBases().

{
  std::vector<const CEvaluationNode*> commonMultiplications;
  std::vector<const CEvaluationNode*> commonDivisions;
  // additions must have at least one entry
  assert(additions.size() > 0);
  // get all multipllications and divisions from the first entry in additions
  std::vector<const CEvaluationNode*> multiplications, divisions;
  unsigned int i, iMax = additions.size();
  unsigned int iiMax = iMax + subtractions.size();
  std::vector<std::vector<const CEvaluationNode*> > multiplicationVectors, divisionVectors;

  for (i = 0; i < iiMax; ++i)
    {
      const CEvaluationNode* pTmpNode = (i < iMax) ? additions[i] : subtractions[i - iMax];
      CEvaluationNode::Type type = pTmpNode->getType();

      if (CEvaluationNode::type(type) == CEvaluationNode::OPERATOR)
        {
          CEvaluationNodeOperator::SubType subType = (CEvaluationNodeOperator::SubType)CEvaluationNode::subType(type);

          if (subType == CEvaluationNodeOperator::MULTIPLY || subType == CEvaluationNodeOperator::DIVIDE)
            {
              CNormalTranslation::splitProduct(pTmpNode, multiplications, divisions, false);
            }
          else
            {
              multiplications.push_back(pTmpNode);
            }
        }
      else
        {
          multiplications.push_back(pTmpNode);
        }

      multiplicationVectors.push_back(multiplications);
      divisionVectors.push_back(divisions);
      multiplications.clear();
      divisions.clear();
    }

  // now we first search for common multiplications
  multiplications = multiplicationVectors[0];
  std::vector<const CEvaluationNode*>::const_iterator it = multiplications.begin(), endit = multiplications.end();

  while (it != endit)
    {
      bool everywhere = true;
      std::vector<std::vector<const CEvaluationNode*> >::iterator innerIt = multiplicationVectors.begin(), innerEndit = multiplicationVectors.end();
      // we can leave out the first one since the item comes from there anyway,
      // so we know it is in that vector
      std::string infix = (*it)->buildInfix();
      ++innerIt;

      while (innerIt != innerEndit)
        {
          bool found = false;
          std::vector<const CEvaluationNode*>::iterator innerIt2 = (*innerIt).begin(), innerEndit2 = (*innerIt).end();

          while (innerIt2 != innerEndit2)
            {
              if ((*innerIt2)->buildInfix() == infix)
                {
                  found = true;
                  break;
                }

              ++innerIt2;
            }

          if (!found)
            {
              everywhere = false;
              break;
            }

          ++innerIt;
        }

      // if the item was found as a factor in all other additions and
      // subtractions, we know it is a common factor, we add it to the
      // commonFactors and update the additions and subtractions
      if (everywhere)
        {
          commonMultiplications.push_back(*it);
          std::vector<std::vector<const CEvaluationNode*> >::iterator innerIt = multiplicationVectors.begin();
          std::vector<std::vector<const CEvaluationNode*> >::iterator innerEndit = multiplicationVectors.end();

          while (innerIt != innerEndit)
            {
              std::vector<const CEvaluationNode*>::iterator innerIt2 = (*innerIt).begin();
              std::vector<const CEvaluationNode*>::iterator innerEndit2 = (*innerIt).end();

              while (innerIt2 != innerEndit2)
                {
                  if ((*innerIt2)->buildInfix() == infix)
                    {
                      innerIt->erase(innerIt2);
                      break;
                    }

                  ++innerIt2;
                }

              ++innerIt;
            }
        }

      ++it;
    }

  // now we search for common divisions
  divisions = divisionVectors[0];

  if (!divisions.empty())
    {
      it = divisions.begin(), endit = divisions.end();

      while (it != endit)
        {
          bool everywhere = true;
          std::vector<std::vector<const CEvaluationNode*> >::iterator innerIt = divisionVectors.begin(), innerEndit = divisionVectors.end();
          // we can leav out the first one since the item comes from there anyway,
          // so we know it is in that vector
          std::string infix = (*it)->buildInfix();
          ++innerIt;

          while (innerIt != innerEndit)
            {
              bool found = false;
              std::vector<const CEvaluationNode*>::iterator innerIt2 = (*innerIt).begin(), innerEndit2 = (*innerIt).end();

              while (innerIt2 != innerEndit2)
                {
                  if ((*innerIt2)->buildInfix() == infix)
                    {
                      found = true;
                      break;
                    }

                  ++innerIt2;
                }

              if (!found)
                {
                  everywhere = false;
                  break;
                }

              ++innerIt;
            }

          // if the item was found as a factor in all other additions and
          // subtractions, we know it is a common factor, we add it to the
          // commonFactors and update the additions and subtractions
          if (everywhere)
            {
              commonDivisions.push_back(*it);
              innerIt = divisionVectors.begin();
              innerEndit = divisionVectors.end();

              while (innerIt != innerEndit)
                {
                  std::vector<const CEvaluationNode*>::iterator innerIt2 = (*innerIt).begin();
                  std::vector<const CEvaluationNode*>::iterator innerEndit2 = (*innerIt).end();

                  while (innerIt2 != innerEndit2)
                    {
                      if ((*innerIt2)->buildInfix() == infix)
                        {
                          innerIt->erase(innerIt2);
                          break;
                        }

                      ++innerIt2;
                    }

                  ++innerIt;
                }
            }

          ++it;
        }
    }

  // create the two resulting nodes
  // first we have to create new additions and subtraction vectors which we
  // then combine into a subtraction
  // then we combine all commonMultiplications and commonDivisions into a
  // division
  // those two nodes are then returned in a pair
  CEvaluationNode* pFirstNode = NULL;
  CEvaluationNode* pSecondNode = NULL;

  if (!(commonMultiplications.empty() && commonDivisions.empty()))
    {
      unsigned int i, iMax = additions.size();
      unsigned int iiMax = iMax + subtractions.size();
      std::vector<CEvaluationNode*> newAdditions, newSubtractions;

      for (i = 0; i < iiMax; ++i)
        {
          // since the createOperatorChain automatically returns 1 as the result
          // if an empty vector is given, we don't have to worry about havinf
          // removed all items from the vectors above.
          CEvaluationNode* pTmpNode = CNormalTranslation::createOperatorChain(CEvaluationNodeOperator::MULTIPLY, "*", multiplicationVectors[i]);

          if (!divisionVectors[i].empty())
            {
              CEvaluationNode* pTmpNode2 = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE, "/");
              pTmpNode2->addChild(pTmpNode);
              pTmpNode2->addChild(CNormalTranslation::createOperatorChain(CEvaluationNodeOperator::MULTIPLY, "*", divisionVectors[i]));
              pTmpNode = pTmpNode2;
            }

          if (i < iMax)
            {
              newAdditions.push_back(pTmpNode);
            }
          else
            {
              newSubtractions.push_back(pTmpNode);
            }
        }

      pSecondNode = CNormalTranslation::createChain(&CNormalTranslation::PLUS_NODE, &CNormalTranslation::ZERO_NODE, newAdditions);
      assert(pSecondNode != NULL);

      if (!newSubtractions.empty())
        {
          CEvaluationNode* pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MINUS, "-");
          pTmpNode->addChild(pSecondNode);
          pTmpNode->addChild(CNormalTranslation::createChain(&CNormalTranslation::PLUS_NODE, &CNormalTranslation::ZERO_NODE, newSubtractions));
          assert(pTmpNode != NULL);
          pSecondNode = pTmpNode;
        }

      pFirstNode = CNormalTranslation::createOperatorChain(CEvaluationNodeOperator::MULTIPLY, "*", commonMultiplications);

      if (!commonDivisions.empty())
        {
          CEvaluationNode* pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE, "/");
          pTmpNode->addChild(pFirstNode);
          pTmpNode->addChild(CNormalTranslation::createOperatorChain(CEvaluationNodeOperator::MULTIPLY, "*", commonDivisions));
          pFirstNode = pTmpNode;
        }
    }

  return std::pair<CEvaluationNode*, CEvaluationNode*>(pFirstNode, pSecondNode);
}

void CNormalTranslation::findNegativeNumbers ( std::vector< const CEvaluationNode * > &  v1, std::vector< CEvaluationNode * > &  v2  )

staticprotected

This routine finds all negative numbers in vector v1 and adds a copy with a positive number to v2

Definition at line 6216 of file CNormalTranslation.cpp.

References CEvaluationNode::copyBranch(), CEvaluationNode::copyNode(), CEvaluationNodeNumber::DOUBLE, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNode::getValue(), CEvaluationNodeOperator::MULTIPLY, CEvaluationNode::NUMBER, CEvaluationNode::OPERATOR, CEvaluationNode::subType(), and CEvaluationNode::type().

Referenced by newCancel().

{
  const CEvaluationNode* pNode;
  CEvaluationNode::Type type, type1, type2;
  std::vector<const CEvaluationNode*>::iterator it = v1.begin(), endit = v1.end();
  std::ostringstream os;

  while (it != endit)
    {
      pNode = *it;
      type = pNode->getType();

      if (CEvaluationNode::type(type) == CEvaluationNode::NUMBER && pNode->getValue() < 0.0)
        {
          it = v1.erase(it);
          endit = v1.end();
          os.str("");
          os.precision(18);
          os << pNode->getValue() * -1.0;
          v2.push_back(new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str()));
          continue;
        }
      else if (CEvaluationNode::type(type) == CEvaluationNode::OPERATOR && (CEvaluationNodeOperator::SubType)CEvaluationNode::subType(type) == CEvaluationNodeOperator::MULTIPLY)
        {
          const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(pNode->getChild());
          assert(pChild1 != NULL);
          const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
          assert(pChild2 != NULL);
          type1 = CEvaluationNode::type(pChild1->getType());
          type2 = CEvaluationNode::type(pChild2->getType());

          if (type1 == CEvaluationNode::NUMBER || type2 == CEvaluationNode::NUMBER)
            {
              if (type1 == CEvaluationNode::NUMBER && type2 == CEvaluationNode::NUMBER)
                {
                  if (pChild1->getValue() < 0.0 && pChild2->getValue() < 0.0)
                    {
                      // we should never end up here because
                      // elementaryElimination should take care of this case
                      assert(false);
                      continue;
                    }
                  else if (pChild1->getValue() < 0.0)
                    {
                      os.str("");
                      os.precision(18);
                      os << pChild1->getValue() * -1.0;
                      CEvaluationNodeNumber* pTmpNode = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str());
                      std::vector<CEvaluationNode*> children;
                      children.push_back(pTmpNode);
                      children.push_back(pChild2->copyBranch());
                      CEvaluationNode* pNewNode = pNode->copyNode(children);
                      v2.push_back(pNewNode);
                      it = v1.erase(it);
                      endit = v1.end();
                      continue;
                    }
                  else if (pChild2->getValue() < 0.0)
                    {
                      os.str("");
                      os.precision(18);
                      os << pChild2->getValue() * -1.0;
                      CEvaluationNodeNumber* pTmpNode = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str());
                      std::vector<CEvaluationNode*> children;
                      children.push_back(pChild1->copyBranch());
                      children.push_back(pTmpNode);
                      CEvaluationNode* pNewNode = pNode->copyNode(children);
                      v2.push_back(pNewNode);
                      it = v1.erase(it);
                      endit = v1.end();
                      continue;
                    }
                }
              else if (type1 == CEvaluationNode::NUMBER)
                {
                  if (pChild1->getValue() < 0.0)
                    {
                      os.str("");
                      os.precision(18);
                      os << pChild1->getValue() * -1.0;
                      CEvaluationNodeNumber* pTmpNode = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str());
                      std::vector<CEvaluationNode*> children;
                      children.push_back(pTmpNode);
                      children.push_back(pChild2->copyBranch());
                      CEvaluationNode* pNewNode = pNode->copyNode(children);
                      v2.push_back(pNewNode);
                      it = v1.erase(it);
                      endit = v1.end();
                      continue;
                    }
                }
              else
                {
                  if (pChild2->getValue() < 0.0)
                    {
                      os.str("");
                      os.precision(18);
                      os << pChild2->getValue() * -1.0;
                      CEvaluationNodeNumber* pTmpNode = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str());
                      std::vector<CEvaluationNode*> children;
                      children.push_back(pChild1->copyBranch());
                      children.push_back(pTmpNode);
                      CEvaluationNode* pNewNode = pNode->copyNode(children);
                      v2.push_back(pNewNode);
                      it = v1.erase(it);
                      endit = v1.end();
                      continue;
                    }
                }
            }
        }

      ++it;
    }
}

void CNormalTranslation::findSummands ( const CEvaluationNode *  pRoot, std::vector< const CEvaluationNode * > &  summands  )

static

Given a node, the method check if the node is a PLUS node, if so, it calls itself recursively on the children. This way all summands of a summation chain are gathered. All items in the vector are children of pRoot.

This method takes a node and if the node is the node is an addition operator, the method goes through the children of the node and check for more addition operators. All children of addition operators are added to the given summands vector. If the given node is not an addition operator, the methods adds the node itself to the vector of summands. The nodes that are added to the vector are the original nodes and not copies.

Definition at line 347 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNode::OPERATOR, CEvaluationNodeOperator::PLUS, CEvaluationNode::subType(), and CEvaluationNode::type().

Referenced by expandPowerExponents().

{
  if (CEvaluationNode::type(pRoot->getType()) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pRoot->getType())) == CEvaluationNodeOperator::PLUS)
    {
      const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(pRoot->getChild());
      assert(pChild1 != NULL);

      if (pChild1 != NULL)
        {
          const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
          assert(pChild2 != NULL);

          if (pChild2 != NULL)
            {
              assert(pChild2->getSibling() == NULL);

              if (CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pChild1->getType())) == CEvaluationNodeOperator::PLUS)
                {
                  CNormalTranslation::findSummands(pChild1, summands);
                }
              else
                {
                  summands.push_back(pChild1);
                }

              if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pChild2->getType())) == CEvaluationNodeOperator::PLUS)
                {
                  CNormalTranslation::findSummands(pChild2, summands);
                }
              else
                {
                  summands.push_back(pChild2);
                }
            }
        }
    }
  else
    {
      summands.push_back(pRoot);
    }
}

bool CNormalTranslation::has_duplicate_nodes ( const CEvaluationNode *  pNode )

static

Definition at line 6407 of file CNormalTranslation.cpp.

References CEvaluationNodeDepthFirstIterator::isValid().

{
  bool result = false;
  CEvaluationNodeDepthFirstIterator it(const_cast<CEvaluationNode*>(pNode));
  std::set<const CEvaluationNode*> s;

  while (it.isValid())
    {
      if (s.find(*it) == s.end())
        {
          s.insert(*it);
        }
      else
        {
          result = true;
          break;
        }

      ++it;
    }

  return result;
}

std::vector< product_match > CNormalTranslation::matchPowerBases ( const std::vector< const CEvaluationNode * > &  multiplications, const std::vector< const CEvaluationNode * > &  divisions  )

staticprotected

The methods get a vector of multiplication elements and a vector of division elements and tries to find elements with the same power base in those two vectors.

The methods get a vector of multiplication elements and a vector of division elements and tries to find elements with the same power base in those two vectors. e.g. A^3 and A^x would have the same power base A.

The nodes in the match are copies of the original nodes

Definition at line 2923 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), summ_match::addition_indices, CEvaluationNode::buildInfix(), CEvaluationNode::copyBranch(), createNormalRepresentation(), CEvaluationNodeNumber::DOUBLE, summ_match::factor, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNode::getValue(), CEvaluationNodeOperator::MINUS, CEvaluationNodeOperator::MULTIPLY, newEvaluateNumbers(), CEvaluationNode::NUMBER, CEvaluationNode::OPERATOR, product_match::pExponentNode, CEvaluationNodeOperator::PLUS, summ_match::pNode, CEvaluationNodeOperator::POWER, summ_match::subtraction_indices, CEvaluationNode::subType(), CNormalFraction::toString(), and CEvaluationNode::type().

Referenced by newCancel().

{
  std::map<const CEvaluationNode*, product_match> matchMap;
  std::map<std::string, const CEvaluationNode*> infixMap;
  std::map<const CEvaluationNode*, product_match>::iterator matchPos;
  std::map<std::string, const CEvaluationNode*>::iterator infixPos;

  std::vector<const CEvaluationNode*>::const_iterator vit = multiplications.begin(), vendit = multiplications.end();
  const CEvaluationNode* pBase = NULL;
  const CNormalFraction* pBase2 = NULL;
  std::string base2String;
  CEvaluationNode *pExponent = NULL, *pAddNode = NULL;
  unsigned int index = 0;
  product_match match;
  // we store the order in which the base strings occur
  // so that we can return the result in approximately the same order
  // this should help in eliminating loops of chains with alternating order
  std::list<const CEvaluationNode*> orderList;

  while (vit != vendit)
    {
      pBase = (*vit);
      pExponent = NULL;

      if (CEvaluationNode::type(pBase->getType()) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pBase->getType())) == CEvaluationNodeOperator::POWER)
        {
          pBase = dynamic_cast<const CEvaluationNode*>(pBase->getChild());
          pExponent = dynamic_cast<const CEvaluationNode*>(pBase->getSibling())->copyBranch();
        }

      // check if a base with the same infix is already in the map.
      // if not, add the base
      // if yes, add the exponent to the vector associated with the base
      //
      // we only need to create the infix through a normal base if the
      // object is complex
      if (pBase->getChild() != NULL)
        {
          pBase2 = createNormalRepresentation(pBase);
          base2String = pBase2->toString();
          delete pBase2;
          pBase2 = NULL;
        }
      else
        {
          base2String = pBase->buildInfix();
        }

      infixPos = infixMap.find(base2String);

      if (infixPos != infixMap.end())
        {
          matchPos = matchMap.find(infixPos->second);
          assert(matchPos != matchMap.end());

          if (matchPos != matchMap.end())
            {
              if (pExponent != NULL)
                {
                  if (matchPos->second.pExponentNode != NULL)
                    {
                      pAddNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::PLUS , "+");
                      pAddNode->addChild(matchPos->second.pExponentNode);
                      pAddNode->addChild(pExponent);
                      matchPos->second.pExponentNode = pAddNode;
                      matchPos->second.addition_indices.insert(index);
                    }
                  else
                    {
                      matchPos->second.pExponentNode = pExponent;
                    }
                }
              else
                {
                  matchPos->second.factor += 1.0;
                }
            }
        }
      else
        {
          match.pNode = pBase->copyBranch();

          if (pExponent == NULL)
            {
              match.factor = 1.0;
            }
          else
            {
              match.factor = 0.0;
            }

          match.pExponentNode = pExponent;
          match.addition_indices.clear();
          match.addition_indices.insert(index);
          match.subtraction_indices.clear();
          infixMap.insert(std::pair<std::string, const CEvaluationNode*>(base2String, pBase));
          matchMap.insert(std::pair<const CEvaluationNode*, product_match>(pBase, match));
          orderList.push_back(pBase);
        }

      ++index;
      ++vit;
    }

  vit = divisions.begin(), vendit = divisions.end();

  index = 0;

  while (vit != vendit)
    {
      pBase = (*vit);
      pExponent = NULL;

      if (CEvaluationNode::type(pBase->getType()) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pBase->getType())) == CEvaluationNodeOperator::POWER)
        {
          pBase = dynamic_cast<const CEvaluationNode*>(pBase->getChild());
          pExponent = dynamic_cast<const CEvaluationNode*>(pBase->getSibling())->copyBranch();
        }
      else
        {
          pExponent = NULL;
        }

      // check if a base with the same infix is already in the map.
      // if not, add the base
      // if yes, add the exponent to the vector associated with the base
      if (pBase->getChild() != NULL)
        {
          pBase2 = createNormalRepresentation(pBase);
          base2String = pBase2->toString();
          delete pBase2;
          pBase2 = NULL;
        }
      else
        {
          base2String = pBase->buildInfix();
        }

      infixPos = infixMap.find(base2String);

      if (infixPos != infixMap.end())
        {
          matchPos = matchMap.find(infixPos->second);
          assert(matchPos != matchMap.end());

          if (matchPos != matchMap.end())
            {
              if (pExponent != NULL)
                {
                  if (matchPos->second.pExponentNode != NULL)
                    {
                      pAddNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MINUS , "-");
                      pAddNode->addChild(matchPos->second.pExponentNode);
                      pAddNode->addChild(pExponent);
                      matchPos->second.pExponentNode = pAddNode;
                      matchPos->second.subtraction_indices.insert(index);
                    }
                  else
                    {
                      // we have to add -1 * pExponent
                      pAddNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
                      pAddNode->addChild(new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "-1.0"));
                      pAddNode->addChild(pExponent);
                      matchPos->second.pExponentNode = pAddNode;
                    }
                }
              else
                {
                  // subtract one from the factor
                  matchPos->second.factor -= 1.0;
                }
            }
        }
      else
        {
          match.pNode = pBase->copyBranch();

          if (pExponent == NULL)
            {
              match.factor = -1.0;
              match.pExponentNode = NULL;
            }
          else
            {
              // we have to add -1 * pExponent
              match.factor = 0.0;
              pAddNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
              pAddNode->addChild(new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "-1.0"));
              pAddNode->addChild(pExponent);
              match.pExponentNode = pAddNode;
            }

          match.addition_indices.clear();
          match.subtraction_indices.clear();
          match.subtraction_indices.insert(index);
          infixMap.insert(std::pair<std::string, const CEvaluationNode*>(base2String, pBase));
          matchMap.insert(std::pair<const CEvaluationNode*, product_match>(pBase, match));
          orderList.push_back(pBase);
        }

      ++index;
      ++vit;
    }

  // create the result vector
  std::vector<product_match> result;
  CEvaluationNode* pTmpNode = NULL;
  std::ostringstream os;

  std::list<const CEvaluationNode*>::const_iterator orderIt = orderList.begin(), orderEndit = orderList.end();

  while (orderIt != orderEndit)
    {
      matchPos = matchMap.find(*orderIt);
      assert(matchPos != matchMap.end());

      if (matchPos != matchMap.end())
        {

          // call newEvaluateNumbers on pExponentNode of each match
          if (matchPos->second.pExponentNode != NULL)
            {
              if (CEvaluationNode::type(matchPos->second.pExponentNode->getType()) == CEvaluationNode::NUMBER)
                {
                  // add the numerical value to factor
                  matchPos->second.factor += matchPos->second.pExponentNode->getValue();
                  // and delete the exponent node
                  delete matchPos->second.pExponentNode;
                  matchPos->second.pExponentNode = NULL;
                }
              else
                {
                  pTmpNode = CNormalTranslation::newEvaluateNumbers(matchPos->second.pExponentNode);

                  if (pTmpNode != NULL)
                    {
                      if (CEvaluationNode::type(pTmpNode->getType()) == CEvaluationNode::NUMBER)
                        {
                          // add the numerical value to factor
                          matchPos->second.factor += pTmpNode->getValue();
                          // and delete the exponent node
                          delete matchPos->second.pExponentNode;
                          matchPos->second.pExponentNode = NULL;
                        }
                      else
                        {
                          // replace the exponent node
                          delete matchPos->second.pExponentNode;
                          matchPos->second.pExponentNode = pTmpNode;
                        }
                    }
                  else
                    {
                      // add the factor to the exponent node
                      // and set the factor to 0.0
                      if (matchPos->second.factor != 0.0)
                        {
                          os.str("");
                          os.precision(18);
                          os << matchPos->second.factor;
                          pExponent = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str());
                          pAddNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::PLUS, "+");
                          pAddNode->addChild(pExponent);
                          pAddNode->addChild(matchPos->second.pExponentNode);
                          matchPos->second.pExponentNode = pAddNode;
                          matchPos->second.factor = 0.0;
                        }

                    }
                }
            }

          result.push_back(matchPos->second);
        }

      ++orderIt;
    }

  return result;
}

std::vector< std::pair< CEvaluationNode *, CEvaluationNode * > > CNormalTranslation::matchSummands ( const std::vector< CEvaluationNode * > &  additions, const std::vector< CEvaluationNode * > &  subtractions  )

staticprotected

The methods get a vector of addition elements and a vector of subtractions elements and tries to find equal elements in those two vectors.

The methods get a vector of multiplication elements and a vector of division elements and tries to find elements with the same power base in those two vectors.

std::vector<std::pair<CEvaluationNode*, CEvaluationNode*> > CNormalTranslation::matchPowerBases(const std::vector<const CEvaluationNode*>& multiplications, const std::vector<const CEvaluationNode*>& divisions) { std::vector<std::pair<std::pair<const CEvaluationNode*, std::string>, std::vector<CEvaluationNode*> > > matchMap; std::vector<const CEvaluationNode*>::const_iterator vit = multiplications.begin(), vendit = multiplications.end();

while (vit != vendit) { const CEvaluationNode* pBase = (vit); CEvaluationNode pExponent = NULL;

if (CEvaluationNode::type(pBase->getType()) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pBase->getType())) == CEvaluationNodeOperator::POWER) { pBase = dynamic_cast<const CEvaluationNode*>(pBase->getChild()); pExponent = dynamic_cast<const CEvaluationNode*>(pBase->getSibling())->copyBranch(); } else { pExponent = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0"); }

check if a base with the same infix is already in the map. if not, add the base if yes, add the exponent to the vector associated with the base std::vector<std::pair<std::pair<const CEvaluationNode*, std::string>, std::vector<CEvaluationNode*> > >::iterator mapIt = matchMap.begin(), mapEndit = matchMap.end(); CNormalFraction* pBase2 = createNormalRepresentation(pBase); std::string base2String = pBase2->toString(); delete pBase2;

while (mapIt != mapEndit) { if (mapIt->first.second == base2String) { mapIt->second.push_back(pExponent); break; }

++mapIt; }

if (mapIt == mapEndit) { std::vector<CEvaluationNode*> v; v.push_back(pExponent); matchMap.push_back(std::make_pair(std::pair<const CEvaluationNode*, std::string>(pBase, base2String), v)); }

++vit; }

std::vector<std::pair<std::pair<const CEvaluationNode*, std::string>, std::vector<CEvaluationNode*> > > matchMap2; vit = divisions.begin(), vendit = divisions.end();

while (vit != vendit) { const CEvaluationNode* pBase = (vit); CEvaluationNode pExponent = NULL;

if (CEvaluationNode::type(pBase->getType()) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pBase->getType())) == CEvaluationNodeOperator::POWER) { pBase = dynamic_cast<const CEvaluationNode*>(pBase->getChild()); pExponent = dynamic_cast<const CEvaluationNode*>(pBase->getSibling())->copyBranch(); } else { pExponent = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0"); }

check if a base with the same infix is already in the map. if not, add the base if yes, add the exponent to the vector associated with the base std::vector<std::pair<std::pair<const CEvaluationNode*, std::string>, std::vector<CEvaluationNode*> > >::iterator mapIt = matchMap2.begin(), mapEndit = matchMap2.end(); CNormalFraction* pBase2 = createNormalRepresentation(pBase); std::string base2String = pBase2->toString(); delete pBase2;

while (mapIt != mapEndit) { if (mapIt->first.second == base2String) { mapIt->second.push_back(pExponent); break; }

++mapIt; }

if (mapIt == mapEndit) { std::vector<CEvaluationNode*> v; v.push_back(pExponent); matchMap2.push_back(std::make_pair(std::pair<const CEvaluationNode*, std::string>(pBase, base2String), v)); }

++vit; }

now combine the two maps std::vector<std::pair<CEvaluationNode*, std::pair<CEvaluationNode*, std::string> > > result; std::vector<std::pair<std::pair<const CEvaluationNode*, std::string>, std::vector<CEvaluationNode*> > >::iterator mapIt = matchMap.begin(), mapEndit = matchMap.end();

while (mapIt != mapEndit) { CEvaluationNode* pNode = CNormalTranslation::createChain(&CNormalTranslation::PLUS_NODE, &CNormalTranslation::ZERO_NODE, mapIt->second); assert(pNode != NULL); result.push_back(std::make_pair(pNode, std::pair<CEvaluationNode*, std::string>(mapIt->first.first->copyBranch(), mapIt->first.second))); ++mapIt; }

mapIt = matchMap2.begin(), mapEndit = matchMap2.end();

while (mapIt != mapEndit) { std::vector<CEvaluationNode*> constVect; constVect.insert(constVect.begin(), mapIt->second.begin(), mapIt->second.end()); CEvaluationNode* pNode = CNormalTranslation::createOperatorChain(CEvaluationNodeOperator::PLUS, "+", constVect); now check if we already have a base with the same infix in the results unsigned int i, iMax = result.size();

for (i = 0; i < iMax; ++i) { if (result[i].second.second == mapIt->first.second) { CEvaluationNode* pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MINUS, "-"); pTmpNode->addChild(result[i].first); pTmpNode->addChild(pNode); result[i] = std::make_pair(pTmpNode, result[i].second); break; } }

if (i == iMax) { if (CEvaluationNode::type(pNode->getType()) == CEvaluationNode::NUMBER) { std::ostringstream os; os.precision(18); os << static_cast<CEvaluationNodeNumber*>(pNode)->getValue() * -1.0; CEvaluationNode* pTmpNumber = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str()); delete pNode; result.push_back(std::make_pair(pTmpNumber, std::pair<CEvaluationNode*, std::string>(mapIt->first.first->copyBranch(), mapIt->first.second))); } else { CEvaluationNode* pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*"); pTmpNode->addChild(new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "-1.0")); pTmpNode->addChild(pNode); result.push_back(std::make_pair(pTmpNode, std::pair<CEvaluationNode*, std::string>(mapIt->first.first->copyBranch(), mapIt->first.second))); } }

delete the obsolete nodes iMax = mapIt->second.size();

for (i = 0; i < iMax; ++i) { delete mapIt->second[i]; }

++mapIt; }

copy the result vector into the return data structure std::vector<std::pair<CEvaluationNode*, CEvaluationNode*> > tmp; unsigned int i, iMax = result.size(); since we know how many elements will end up in tmp, we can already reserve the space tmp.reserve(iMax);

for (i = 0; i < iMax; ++i) { tmp.push_back(std::pair<CEvaluationNode*, CEvaluationNode*>(result[i].first, result[i].second.first)); }

return tmp; } The methods get a vector of addition elements and a vector of subtractions elements and tries to find equal elements in those two vectors.

Definition at line 3587 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNode::buildInfix(), CEvaluationNode::copyBranch(), createChain(), createNormalRepresentation(), createOperatorChain(), CEvaluationNodeNumber::DOUBLE, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNodeOperator::MINUS, CEvaluationNodeOperator::MULTIPLY, CEvaluationNode::NUMBER, CEvaluationNode::OPERATOR, CEvaluationNodeOperator::PLUS, CEvaluationNode::subType(), CNormalFraction::toString(), and CEvaluationNode::type().

Referenced by newCancel().

{
  // the individual elements could be  multiplication chains and there could
  // be a common factor somewhere in the chain
  // Since I only want to get rid of numbers, it might be enough to
  // consider only those multiplication chains the contain a number node and
  // something else, everything else is ambiguous anyway and depends on
  // the order of the nodes in the chain
  std::vector<std::pair<std::pair<const CEvaluationNode*, std::string>, std::vector<CEvaluationNode*> > > matchMap;

  std::vector<CEvaluationNode*>::const_iterator vit = additions.begin(), vendit = additions.end();

  while (vit != vendit)
    {
      const CEvaluationNode* pNode = (*vit);
      CEvaluationNode* pFactor = NULL;

      if (CEvaluationNode::type(pNode->getType()) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pNode->getType())) == CEvaluationNodeOperator::MULTIPLY)
        {
          const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(pNode->getChild());
          assert(pChild1 != NULL);
          const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
          assert(pChild2 != NULL);
          assert(pChild2->getSibling() == NULL);

          if (CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::NUMBER)
            {
              pNode = pChild2;
              pFactor = pChild1->copyBranch();
            }
          else if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER)
            {
              pNode = pChild1;
              pFactor = pChild2->copyBranch();
            }
          else
            {
              pFactor = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0");
            }
        }
      else
        {
          pFactor = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0");
        }

      // check if a node with the same infix is already in the map.
      // if not, add the base
      // if yes, add the exponent to the vector associated with the base
      std::string base2String;

      if (pNode->getChild() != NULL)
        {
          CNormalFraction* pBase2 = createNormalRepresentation(pNode);
          base2String = pBase2->toString();
          delete pBase2;
          pBase2 = NULL;
        }
      else
        {
          base2String = pNode->buildInfix();
        }

      std::vector<std::pair<std::pair<const CEvaluationNode*, std::string>, std::vector<CEvaluationNode*> > >::iterator mapIt = matchMap.begin(), mapEndit = matchMap.end();

      while (mapIt != mapEndit)
        {
          if (mapIt->first.second == base2String)
            {
              mapIt->second.push_back(pFactor);
              break;
            }

          ++mapIt;
        }


      if (mapIt == mapEndit)
        {
          std::vector<CEvaluationNode*> v;
          v.push_back(pFactor);
          matchMap.push_back(std::make_pair(std::pair<const CEvaluationNode*, std::string>(pNode, base2String), v));
        }

      ++vit;
    }

  std::vector<std::pair<std::pair<const CEvaluationNode*, std::string>, std::vector<CEvaluationNode*> > > matchMap2;
  vit = subtractions.begin(), vendit = subtractions.end();

  while (vit != vendit)
    {
      const CEvaluationNode* pNode = (*vit);
      CEvaluationNode* pFactor = NULL;

      if (CEvaluationNode::type(pNode->getType()) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pNode->getType())) == CEvaluationNodeOperator::MULTIPLY)
        {
          const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(pNode->getChild());
          assert(pChild1 != NULL);
          const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
          assert(pChild2 != NULL);
          assert(pChild2->getSibling() == NULL);

          if (CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::NUMBER)
            {
              pNode = pChild2;
              pFactor = pChild1->copyBranch();
            }
          else if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER)
            {
              pNode = pChild1;
              pFactor = pChild2->copyBranch();
            }
          else
            {
              pFactor = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0");
            }
        }
      else
        {
          pFactor = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0");
        }

      // check if a node with the same infix is already in the map.
      // if not, add the node
      // if yes, add the 1 to the vector associated with the base
      std::vector<std::pair<std::pair<const CEvaluationNode*, std::string>, std::vector<CEvaluationNode*> > >::iterator mapIt = matchMap2.begin(), mapEndit = matchMap2.end();
      std::string base2String;

      if (pNode->getChild() != NULL)
        {
          CNormalFraction* pBase2 = createNormalRepresentation(pNode);
          base2String = pBase2->toString();
          delete pBase2;
        }
      else
        {
          base2String = pNode->buildInfix();
        }

      while (mapIt != mapEndit)
        {
          if (mapIt->first.second == base2String)
            {
              mapIt->second.push_back(pFactor);
              break;
            }

          ++mapIt;
        }


      if (mapIt == mapEndit)
        {
          std::vector<CEvaluationNode*> v;
          v.push_back(pFactor);
          matchMap2.push_back(std::make_pair(std::pair<const CEvaluationNode*, std::string>(pNode, base2String), v));
        }

      ++vit;
    }

  // now combine the two maps
  std::vector<std::pair<CEvaluationNode*, std::pair<CEvaluationNode*, std::string> > > result;
  std::vector<std::pair<std::pair<const CEvaluationNode*, std::string>, std::vector<CEvaluationNode*> > >::iterator mapIt = matchMap.begin(), mapEndit = matchMap.end();

  while (mapIt != mapEndit)
    {
      CEvaluationNode* pNode = CNormalTranslation::createChain(&CNormalTranslation::PLUS_NODE, &CNormalTranslation::ZERO_NODE, mapIt->second);
      assert(pNode != NULL);
      result.push_back(std::make_pair(pNode, std::pair<CEvaluationNode*, std::string>(mapIt->first.first->copyBranch(), mapIt->first.second)));
      ++mapIt;
    }

  mapIt = matchMap2.begin(), mapEndit = matchMap2.end();

  while (mapIt != mapEndit)
    {
      std::vector<CEvaluationNode*> constVect;
      constVect.insert(constVect.begin(), mapIt->second.begin(), mapIt->second.end());
      CEvaluationNode* pNode = CNormalTranslation::createOperatorChain(CEvaluationNodeOperator::PLUS, "+", constVect);
      // now check if we already have a base with the same infix in the
      // results
      unsigned int i, iMax = result.size();

      for (i = 0; i < iMax; ++i)
        {
          if (result[i].second.second == mapIt->first.second)
            {
              CEvaluationNode* pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MINUS, "-");
              pTmpNode->addChild(result[i].first);
              pTmpNode->addChild(pNode);
              result[i] = std::make_pair(pTmpNode, result[i].second);
              break;
            }
        }

      if (i == iMax)
        {
          CEvaluationNode* pTmpNode = NULL;

          if (CEvaluationNode::type(pNode->getType()) == CEvaluationNode::NUMBER)
            {
              std::ostringstream os;
              os.precision(18);
              os << dynamic_cast<const CEvaluationNodeNumber*>(pNode)->getValue() * -1.0;
              pTmpNode = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str());
              delete pNode;
            }
          else
            {
              pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
              pTmpNode->addChild(new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "-1.0"));
              pTmpNode->addChild(pNode);
            }

          result.push_back(std::make_pair(pTmpNode, std::pair<CEvaluationNode*, std::string>(mapIt->first.first->copyBranch(), mapIt->first.second)));
        }

      // delete the obsolete nodes
      iMax = mapIt->second.size();

      for (i = 0; i < iMax; ++i)
        {
          delete mapIt->second[i];
        }

      ++mapIt;
    }

  std::vector<std::pair<CEvaluationNode*, CEvaluationNode*> > tmp;
  // copy the result vector into the expected return data type
  unsigned int i, iMax = result.size();
  // since we know how many item will end up in the vector we can already
  // reserve the space
  tmp.reserve(iMax);

  for (i = 0; i < iMax; ++i)
    {
      tmp.push_back(std::pair<CEvaluationNode*, CEvaluationNode*>(result[i].first, result[i].second.first));
    }

  return tmp;
}

std::vector< summ_match > CNormalTranslation::matchSummands ( const std::vector< const CEvaluationNode * > &  additions, const std::vector< const CEvaluationNode * > &  subtractions  )

staticprotected

The methods get a vector of addition elements and a vector of subtractions elements and tries to find equal elements in those two vectors.

Definition at line 3210 of file CNormalTranslation.cpp.

References summ_match::addition_indices, CEvaluationNode::buildInfix(), CEvaluationNode::copyBranch(), createNormalRepresentation(), summ_match::factor, CCopasiNode< _Data >::getChild(), CEvaluationNode::getType(), CEvaluationNode::getValue(), CEvaluationNodeOperator::MULTIPLY, CEvaluationNode::NUMBER, CEvaluationNode::OPERATOR, summ_match::pNode, summ_match::subtraction_indices, CEvaluationNode::subType(), CNormalFraction::toString(), and CEvaluationNode::type().

{
  // the individual elements could be  multiplication chains and there could
  // be a common factor somewhere in the chain
  // Since I only want to get rid of numbers, it might be enough to
  // consider only those multiplication chains that contain a number node and
  // something else, everything else is ambiguous anyway and depends on
  // the order of the nodes in the chain
  std::map<const CEvaluationNode*, summ_match> matchMap;
  std::map<const CEvaluationNode*, summ_match>::iterator matchPos;
  std::map<std::string, const CEvaluationNode*> infixMap;
  std::map<std::string, const CEvaluationNode*>::iterator infixPos;

  summ_match match;
  std::vector<const CEvaluationNode*>::const_iterator vit = additions.begin(), vendit = additions.end();
  const CEvaluationNode *pNode = NULL, *pChild1 = NULL, *pChild2 = NULL;
  double factor = 0.0;
  CNormalFraction* pBase2 = NULL;
  std::string base2String;
  unsigned int index = 0;
  // we store the order in which the base string occur so that we can
  // return the result in approxiumately the same order, the will help in
  // reducing the problem of loops with changing element order
  std::list<const CEvaluationNode*> orderList;

  while (vit != vendit)
    {
      pNode = (*vit);
      factor = 1.0;

      if (CEvaluationNode::type(pNode->getType()) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pNode->getType())) == CEvaluationNodeOperator::MULTIPLY)
        {
          pChild1 = dynamic_cast<const CEvaluationNode*>(pNode->getChild());
          assert(pChild1 != NULL);
          pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
          assert(pChild2 != NULL);
          assert(pChild2->getSibling() == NULL);

          if (CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::NUMBER)
            {
              pNode = pChild2;
              factor = pChild1->getValue();
            }
          else if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER)
            {
              pNode = pChild1;
              factor = pChild2->getValue();
            }
        }

      // check if a node with the same infix is already in the map.
      // if not, add the base
      // if yes, add the exponent to the vector associated with the base
      if (pNode->getChild() != NULL)
        {
          pBase2 = createNormalRepresentation(pNode);
          base2String = pBase2->toString();
          delete pBase2;
          pBase2 = NULL;
        }
      else
        {
          base2String = pNode->buildInfix();
        }

      infixPos = infixMap.find(base2String);

      if (infixPos != infixMap.end())
        {
          matchPos = matchMap.find(infixPos->second);
          assert(matchPos != matchMap.end());

          if (matchPos != matchMap.end())
            {
              matchPos->second.factor += factor;
              matchPos->second.addition_indices.insert(index);
            }
        }
      else
        {
          match.pNode = pNode->copyBranch();
          match.factor = factor;
          match.addition_indices.clear();
          match.addition_indices.insert(index);
          match.subtraction_indices.clear();
          infixMap.insert(std::pair<std::string, const CEvaluationNode*>(base2String, pNode));
          matchMap.insert(std::pair<const CEvaluationNode*, summ_match>(pNode, match));
          orderList.push_back(pNode);
        }

      ++index;
      ++vit;
    }

  index = 0;

  vit = subtractions.begin(), vendit = subtractions.end();

  while (vit != vendit)
    {
      pNode = (*vit);
      factor = -1.0;

      if (CEvaluationNode::type(pNode->getType()) == CEvaluationNode::OPERATOR && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pNode->getType())) == CEvaluationNodeOperator::MULTIPLY)
        {
          pChild1 = dynamic_cast<const CEvaluationNode*>(pNode->getChild());
          assert(pChild1 != NULL);
          pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
          assert(pChild2 != NULL);
          assert(pChild2->getSibling() == NULL);

          if (CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::NUMBER)
            {
              pNode = pChild2;
              factor = pChild1->getValue();
            }
          else if (CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER)
            {
              pNode = pChild1;
              factor = pChild2->getValue();
            }
        }

      // check if a node with the same infix is already in the map.
      // if not, add the node
      // if yes, add the 1 to the vector associated with the base
      if (pNode->getChild() != NULL)
        {
          pBase2 = createNormalRepresentation(pNode);
          base2String = pBase2->toString();
          delete pBase2;
          pBase2 = NULL;
        }
      else
        {
          base2String = pNode->buildInfix();
        }

      infixPos = infixMap.find(base2String);

      if (infixPos != infixMap.end())
        {
          matchPos = matchMap.find(infixPos->second);
          assert(matchPos != matchMap.end());

          if (matchPos != matchMap.end())
            {
              matchPos->second.factor -= factor;
              matchPos->second.subtraction_indices.insert(index);
            }
        }
      else
        {
          match.pNode = pNode->copyBranch();
          match.factor = factor;
          match.addition_indices.clear();
          match.subtraction_indices.clear();
          match.subtraction_indices.insert(index);
          infixMap.insert(std::pair<std::string, const CEvaluationNode*>(base2String, pNode));
          matchMap.insert(std::pair<const CEvaluationNode*, summ_match>(pNode, match));
          orderList.push_back(pNode);
        }

      ++index;
      ++vit;
    }

  // now combine the two maps
  std::vector<summ_match> result;

  std::list<const CEvaluationNode*>::const_iterator orderIt = orderList.begin(), orderEndit = orderList.end();

  while (orderIt != orderEndit)
    {
      matchPos = matchMap.find(*orderIt);
      assert(matchPos != matchMap.end());

      if (matchPos != matchMap.end())
        {
          result.push_back(matchPos->second);
        }

      ++orderIt;
    }

  return result;
}

CEvaluationNode * CNormalTranslation::multiply ( const CEvaluationNode *  pNode1, const CEvaluationNode *  pNode2  )

staticprotected

Multiplies the two given nodes and returns the result.

Definition at line 3928 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), createChain(), CEvaluationNodeNumber::DOUBLE, CEvaluationNodeOperator::MINUS, CEvaluationNodeOperator::MULTIPLY, CEvaluationNode::NUMBER, pResult, splitSum(), and CEvaluationNode::type().

Referenced by expandProducts().

{
  CEvaluationNode* pResult = NULL;
  std::vector<const CEvaluationNode*> additions1, subtractions1;
  CNormalTranslation::splitSum(pNode1, additions1, subtractions1, false);
  std::vector<const CEvaluationNode*> additions2, subtractions2;
  CNormalTranslation::splitSum(pNode2, additions2, subtractions2, false);
  // multiply every element in additions1 with every element in additions2
  // and subtractions2 the results for the multiplication with the elements
  // of subtractions2 must be multiplied by -1
  // multiply every element in subtraction1 with every element in additions2
  // and subtractions2 the results for the multiplication with the elements
  // of additions2 must be multiplied by -1
  std::vector<CEvaluationNode*> tmp;
  unsigned int i, iMax = additions1.size();

  for (i = 0; i < iMax; ++i)
    {
      unsigned int j, jMax = additions2.size();

      for (j = 0; j < jMax; ++j)
        {
          CEvaluationNode* pMult = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
          pMult->addChild(additions1[i]->copyBranch());
          pMult->addChild(additions2[j]->copyBranch());
          tmp.push_back(pMult);
        }
    }

  iMax = subtractions1.size();

  for (i = 0; i < iMax; ++i)
    {
      unsigned int j, jMax = subtractions2.size();

      for (j = 0; j < jMax; ++j)
        {
          CEvaluationNode* pMult = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
          pMult->addChild(subtractions1[i]->copyBranch());
          pMult->addChild(subtractions2[j]->copyBranch());
          tmp.push_back(pMult);
        }
    }

  if (!tmp.empty())
    {
      pResult = CNormalTranslation::createChain(&CNormalTranslation::PLUS_NODE, &CNormalTranslation::ZERO_NODE, tmp);
      assert(pResult != NULL);
      tmp.clear();
    }

  iMax = additions1.size();

  for (i = 0; i < iMax; ++i)
    {
      unsigned int j, jMax = subtractions2.size();

      for (j = 0; j < jMax; ++j)
        {
          CEvaluationNode* pMult = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
          pMult->addChild(additions1[i]->copyBranch());
          pMult->addChild(subtractions2[j]->copyBranch());
          tmp.push_back(pMult);
        }
    }

  iMax = subtractions1.size();

  for (i = 0; i < iMax; ++i)
    {
      unsigned int j, jMax = additions2.size();

      for (j = 0; j < jMax; ++j)
        {
          CEvaluationNode* pMult = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
          pMult->addChild(subtractions1[i]->copyBranch());
          pMult->addChild(additions2[j]->copyBranch());
          tmp.push_back(pMult);
        }
    }

  if (!tmp.empty())
    {
      if (pResult != NULL)
        {
          CEvaluationNode* pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MINUS, "-");
          pTmpNode->addChild(pResult);
          pResult = pTmpNode;
          pTmpNode = CNormalTranslation::createChain(&CNormalTranslation::PLUS_NODE, &CNormalTranslation::ZERO_NODE, tmp);
          assert(pTmpNode != NULL);
          pResult->addChild(pTmpNode);
        }
      else
        {
          if (tmp.size() == 1 && CEvaluationNode::type(tmp[0]->getType()) == CEvaluationNode::NUMBER)
            {
              std::ostringstream os;
              os.precision(18);
              os << tmp[0]->getValue() * -1.0;
              pResult = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str());
              delete tmp[0];
            }
          else
            {
              CEvaluationNode* pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
              pTmpNode->addChild(new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "-1.0"));
              pResult = pTmpNode;
              pTmpNode = CNormalTranslation::createChain(&CNormalTranslation::PLUS_NODE, &CNormalTranslation::ZERO_NODE, tmp);
              assert(pTmpNode != NULL);
              pResult->addChild(pTmpNode);
            }
        }
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::newCancel ( const CEvaluationNode *  pOrig )

staticprotected

This method does all the canceling on a given node and its children. New non-recursive cancel method. This method does all the canceling on a given node and its children. If no canceling was done, NULL is returned.

New non-recursive cancel method. This method does all the canceling on a given node and its children. If no canceling was done, NULL is returned.

Definition at line 4050 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNode::copyBranch(), createChain(), CEvaluationNodeOperator::DIVIDE, CEvaluationNodeNumber::DOUBLE, summ_match::factor, findNegativeNumbers(), CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getParent(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNodeDepthFirstIterator::isValid(), matchPowerBases(), matchSummands(), CEvaluationNodeOperator::MINUS, CEvaluationNodeOperator::MULTIPLY, CEvaluationNode::OPERATOR, product_match::pExponentNode, CEvaluationNodeOperator::PLUS, summ_match::pNode, CEvaluationNodeOperator::POWER, pResult, splitProduct(), splitSum(), CEvaluationNode::subType(), CEvaluationNode::type(), and ZERO.

Referenced by eliminate(), and simplify().

{
  //
  // try to find multiplication chains where something is divided by itself
  // or multiplied by -1 times itself
  // also consider powers (it's the bases that have to match)
  //
  // try to find addition changes where there is a subtraction of two
  // identical nodes or an addition of one node and the same node times -1
  bool modified = false;
  // make a copy of the node
  CEvaluationNode* pResult = pOrig->copyBranch();
  assert(pResult != NULL);
  CEvaluationNodeDepthFirstIterator dfi(pResult);
  CEvaluationNode::Type type;
  CEvaluationNode* pTmpOrig = NULL;
  std::ostringstream os;

  while (dfi.isValid())
    {
      type = CEvaluationNode::type(dfi->getType());

      if (type == CEvaluationNode::OPERATOR)
        {
          const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(dfi->getChild());
          assert(pChild1 != NULL);
          const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
          assert(pChild2 != NULL);
          CEvaluationNodeOperator::SubType subType = (CEvaluationNodeOperator::SubType)CEvaluationNodeOperator::subType(dfi->getType());

          switch (subType)
            {
              case CEvaluationNodeOperator::MULTIPLY:
              case CEvaluationNodeOperator::DIVIDE:
              {
                pTmpOrig = dynamic_cast<CEvaluationNode*>(dfi->getParent());

                // if there is no parent or if the parent is not a multiplication or division, we try to evaluate numbers
                if (pTmpOrig == NULL || CEvaluationNode::type(pTmpOrig->getType()) != CEvaluationNode::OPERATOR || (((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pTmpOrig->getType())) != CEvaluationNodeOperator::MULTIPLY && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pTmpOrig->getType())) != CEvaluationNodeOperator::DIVIDE))
                  {
                    // do the canceling
                    std::vector<const CEvaluationNode*> multiplications, divisions;
                    CNormalTranslation::splitProduct(*dfi, multiplications, divisions, false);
                    // collect all nodes in multiplications and divisions

                    // find identical nodes in multiplications and divisions
                    // The first entry in the pair is the collected power exponent
                    // the second entry is the original power base
                    // make sure the collected factor is again simplified
                    std::vector<product_match> collected = CNormalTranslation::matchPowerBases(multiplications, divisions);

                    // decide if matches were found
                    // if we are working on a copy, we can go and delete those elements, that are no longer needed (e.g. all but the first entry for each match element)
                    // remember to delete the entries in negAdditions and negSubtractions
                    if (collected.size() != (multiplications.size() + divisions.size()))
                      {
                        std::vector<CEvaluationNode*> numeratorChain;
                        std::vector<CEvaluationNode*> denominatorChain;
                        unsigned int iMax = collected.size();

                        for (unsigned int i = 0; i < iMax; ++i)
                          {
                            product_match& match = collected[i];

                            // the matches we get back either have the factor set if it is a pure number,
                            // or they have the pExponentNode set if it can't be represented as a pure number
                            // if simplified node is a 0.0, we ignore this node
                            if (match.pExponentNode == NULL)
                              {
                                if (fabs(match.factor) < ZERO)
                                  {
                                    delete match.pNode;
                                    match.pNode = NULL;
                                  }
                                else if (match.factor > 0.0)
                                  {
                                    if (fabs(match.factor - 1.0) < ZERO)
                                      {
                                        numeratorChain.push_back(match.pNode);
                                      }
                                    else
                                      {
                                        os.str("");
                                        os.precision(18);
                                        os << match.factor;
                                        CEvaluationNode* pPower = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");
                                        pPower->addChild(match.pNode);
                                        pPower->addChild(new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str()));
                                        numeratorChain.push_back(pPower);
                                      }
                                  }
                                else
                                  {
                                    if (fabs(match.factor + 1.0) < ZERO)
                                      {
                                        denominatorChain.push_back(match.pNode);
                                      }
                                    else
                                      {
                                        CEvaluationNode* pPower = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");
                                        pPower->addChild(match.pNode);
                                        os.str("");
                                        os.precision(18);
                                        os << fabs(match.factor);
                                        pPower->addChild(new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str()));
                                        denominatorChain.push_back(pPower);
                                      }
                                  }
                              }
                            else
                              {
                                // since the pExponentNode is not NULL, we can ignore the factor attribute
                                // because it has already been added to the pExponentNode
                                //
                                // since the exponent can't be represented as a number, we probably don't now if the
                                // exponent should be added to divisions or multiplications, so we just add all of them
                                // to the numerator
                                CEvaluationNode* pPower = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");
                                pPower->addChild(match.pNode);
                                pPower->addChild(match.pExponentNode);
                                numeratorChain.push_back(pPower);
                              }
                          }

                        // if there are only divisions, we have an empty numerator chain
                        if (numeratorChain.empty())
                          {
                            pTmpOrig = CNormalTranslation::ONE_NODE.copyBranch();
                          }
                        else
                          {
                            pTmpOrig = CNormalTranslation::createChain(&CNormalTranslation::TIMES_NODE, &CNormalTranslation::ONE_NODE, numeratorChain);
                          }

                        assert(pTmpOrig != NULL);

                        if (!denominatorChain.empty())
                          {
                            CEvaluationNode* pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE, "/");
                            pTmpNode->addChild(pTmpOrig);
                            pTmpOrig = pTmpNode;
                            pTmpNode = CNormalTranslation::createChain(&CNormalTranslation::TIMES_NODE, &CNormalTranslation::ONE_NODE, denominatorChain);
                            assert(pTmpNode != NULL);
                            pTmpOrig->addChild(pTmpNode);
                          }

                        assert(pTmpOrig != NULL);

                        // now we need to replace dfi in it's parent by pTmpOrig and
                        // delete dfi
                        if (dfi->getParent() != NULL)
                          {
                            dfi->getParent()->addChild(pTmpOrig, *dfi);
                            dfi->getParent()->removeChild(*dfi);
                            delete *dfi;
                            dfi = pTmpOrig;
                          }
                        else
                          {
                            // it must be the root node
                            assert(*dfi == pResult);
                            delete pResult;
                            pResult = pTmpOrig;
                            // we are done
                            dfi = NULL;
                          }

                        modified = true;
                      }
                    else
                      {
                        // clean up
                        std::vector<product_match>::iterator it2 = collected.begin(), endit2 = collected.end();

                        while (it2 != endit2)
                          {
                            if ((*it2).pNode != NULL)
                              {
                                delete(*it2).pNode;

                                if ((*it2).pExponentNode != NULL)
                                  {
                                    delete(*it2).pExponentNode;
                                  }
                              }

                            ++it2;
                          }
                      }
                  }
              }
              break;
              case CEvaluationNodeOperator::PLUS:
              case CEvaluationNodeOperator::MINUS:
              {
                pTmpOrig = dynamic_cast<CEvaluationNode*>(dfi->getParent());

                // if there is no parent or if the parent is not an addition or subtraction, we try to evaluate numbers
                if (pTmpOrig == NULL || CEvaluationNode::type(pTmpOrig->getType()) != CEvaluationNode::OPERATOR || ((((CEvaluationNodeOperator::SubType)CEvaluationNodeOperator::subType(pTmpOrig->getType())) != CEvaluationNodeOperator::PLUS && ((CEvaluationNodeOperator::SubType)CEvaluationNodeOperator::subType(pTmpOrig->getType())) != CEvaluationNodeOperator::MINUS)))
                  {
                    // do the canceling
                    // we are in a sum
                    std::vector<const CEvaluationNode*> additions, subtractions;
                    CNormalTranslation::splitSum(*dfi, additions, subtractions, false);
                    std::vector<CEvaluationNode*> negAdditions, negSubtractions;
                    CNormalTranslation::findNegativeNumbers(additions, negAdditions);
                    CNormalTranslation::findNegativeNumbers(subtractions, negSubtractions);
                    additions.insert(additions.end(), negSubtractions.begin(), negSubtractions.end());
                    subtractions.insert(subtractions.end(), negAdditions.begin(), negAdditions.end());

                    // find identical nodes in additions and subtractions
                    // The first entry in the pair is the collected factor
                    // the second entry is the original branch
                    // make sure the collected factor is again simplified
                    std::vector<summ_match> collected = CNormalTranslation::matchSummands(additions, subtractions);
                    // cleanup the generated objects negXXX vector
                    std::vector<CEvaluationNode*>::iterator it = negAdditions.begin(), endit = negAdditions.end();

                    while (it != endit)
                      {
                        delete *it;
                        ++it;
                      }

                    it = negSubtractions.begin(), endit = negSubtractions.end();

                    while (it != endit)
                      {
                        delete *it;
                        ++it;
                      }

                    // decide if matches were found
                    // if we are working on a copy, we can go and delete those elements, that are no longer needed (e.g. all but the first entry for each match element)
                    if (collected.size() != (additions.size() + subtractions.size()))
                      {
                        std::vector<CEvaluationNode*> chain;
                        unsigned int iMax = collected.size();


                        // now we have to create the result chain
                        // all elements with a negative factor are subtracted and all indices with a
                        // positive factor are added
                        // all nodes with a 0.0 factor are dropped
                        for (unsigned int i = 0; i < iMax; ++i)
                          {
                            summ_match& match = collected[i];

                            // if simplified node is 0.0, we ignore this node
                            if (fabs(match.factor) < ZERO)
                              {
                                delete match.pNode;
                              }
                            else if (fabs(match.factor - 1.0) < ZERO)
                              {
                                chain.push_back(match.pNode);
                              }
                            else
                              {
                                CEvaluationNode* pMult = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
                                os.str("");
                                os.precision(18);
                                os << match.factor;
                                pMult->addChild(new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str()));
                                assert(pMult != NULL);
                                assert(match.pNode != NULL);
                                pMult->addChild(match.pNode);
                                chain.push_back(pMult);
                              }
                          }

                        if (!chain.empty())
                          {
                            // we replace the current node with the result created here
                            pTmpOrig = CNormalTranslation::createChain(&CNormalTranslation::PLUS_NODE, &CNormalTranslation::ZERO_NODE, chain);
                          }
                        else
                          {
                            // we replace the current node with the result created here
                            // the result is 0.0
                            pTmpOrig = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "0.0");
                          }

                        assert(pTmpOrig != NULL);

                        // now we need to replace dfi in it's parent by pTmpOrig and
                        // delete dfi
                        if (dfi->getParent() != NULL)
                          {
                            dfi->getParent()->addChild(pTmpOrig, *dfi);
                            dfi->getParent()->removeChild(*dfi);
                            delete *dfi;
                            dfi = pTmpOrig;
                          }
                        else
                          {
                            // it must be the root node
                            assert(*dfi == pResult);
                            delete pResult;
                            pResult = pTmpOrig;
                            // we are done
                            dfi = NULL;
                          }

                        modified = true;
                      }
                    else
                      {
                        // delete the nodes in collected
                        std::vector<summ_match>::iterator it2 = collected.begin(), endit2 = collected.end();

                        while (it2 != endit2)
                          {
                            if ((*it2).pNode != NULL)
                              {
                                delete(*it2).pNode;
                              }

                            ++it2;
                          }
                      }

                    // the entries in these two vectors can be cleared
                    additions.clear();
                    subtractions.clear();
                  }
              }
              break;
              default:
                break;
            }
        }

      if (dfi.isValid())
        {
          ++dfi;
        }
    }

  if (modified == false)
    {
      delete pResult;
      pResult = NULL;
    }

  return pResult;
}

CEvaluationNode * CNormalTranslation::newEvaluateNumbers ( const CEvaluationNode *  pOrig )

static

This method evaluates operators acting on two numbers This method evaluates operators acting on two numbers

This method replaces operations on two (or more) number nodes by the resulting number node. The returned node is either NULL, or a new node. If the returned node is not NULL, the caller is responsible for freeing the memory of the object.

Obsolete recursive version This method replaces operations on two (or more) number nodes by the resulting number node. The returned node is either NULL, or a new node. If the returned node is not NULL, the caller is responsible for freeing the memory of the object.

Definition at line 1755 of file CNormalTranslation.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNode::copyBranch(), createChain(), CEvaluationNodeOperator::DIVIDE, CEvaluationNodeNumber::DOUBLE, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getParent(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNode::getValue(), CEvaluationNodeOperator::INVALID, CEvaluationNodeDepthFirstIterator::isValid(), CEvaluationNodeOperator::MINUS, CEvaluationNodeFunction::MINUS, CEvaluationNodeOperator::MODULUS, CEvaluationNodeOperator::MULTIPLY, CEvaluationNode::NUMBER, CEvaluationNode::OPERATOR, CEvaluationNodeOperator::PLUS, CEvaluationNodeOperator::POWER, pResult, splitProduct(), splitSum(), CEvaluationNode::subType(), swapNegativeNumbers(), CEvaluationNode::type(), and ZERO.

Referenced by createNormalRepresentation(), matchPowerBases(), and simplify().

{
  // if the node is unmodified, return NULL
  // else try to make the modifications in place instead of copying the whole
  // subtree
  CEvaluationNode* pResult = NULL;
  // remember if we modified anything
  bool modified = false;
  // make a copy of the node
  pResult = pOrig->copyBranch();
  assert(pResult != NULL);
  CEvaluationNodeDepthFirstIterator dfi(pResult);
  CEvaluationNode::Type type;
  CEvaluationNode* pTmpOrig = NULL;

  while (dfi.isValid())
    {
      // check if the current node is an operator
      type = CEvaluationNode::type(dfi->getType());

      if (type == CEvaluationNode::OPERATOR)
        {
          const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(dfi->getChild());
          assert(pChild1 != NULL);
          const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
          assert(pChild2 != NULL);
          CEvaluationNodeOperator::SubType subType = (CEvaluationNodeOperator::SubType)CEvaluationNodeOperator::subType(dfi->getType());

          switch (subType)
            {
              case CEvaluationNodeOperator::POWER:

                if (CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::NUMBER && CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER)
                  {
                    std::ostringstream os;
                    const CEvaluationNodeNumber* pNumberNode1 = dynamic_cast<const CEvaluationNodeNumber*>(pChild1);
                    assert(pNumberNode1 != NULL);
                    const CEvaluationNodeNumber* pNumberNode2 = dynamic_cast<const CEvaluationNodeNumber*>(pChild2);
                    assert(pNumberNode1 != NULL);
                    os << pow(pNumberNode1->getValue(), pNumberNode2->getValue());
                    pTmpOrig = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str());

                    // now we need to replace dfi in it's parent by pTmpOrig and
                    // delete dfi
                    if (dfi->getParent() != NULL)
                      {
                        dfi->getParent()->addChild(pTmpOrig, *dfi);
                        dfi->getParent()->removeChild(*dfi);
                        delete *dfi;
                        dfi = pTmpOrig;
                      }
                    else
                      {
                        // it must be the root node
                        assert(*dfi == pResult);
                        delete pResult;
                        pResult = pTmpOrig;
                        // we are done
                        dfi = NULL;
                      }

                    modified = true;
                  }

                break;
              case CEvaluationNodeOperator::MODULUS:

                if (CEvaluationNode::type(pChild1->getType()) == CEvaluationNode::NUMBER && CEvaluationNode::type(pChild2->getType()) == CEvaluationNode::NUMBER)
                  {
                    std::ostringstream os;
                    const CEvaluationNodeNumber* pNumberNode1 = dynamic_cast<const CEvaluationNodeNumber*>(pChild1);
                    assert(pNumberNode1 != NULL);
                    const CEvaluationNodeNumber* pNumberNode2 = dynamic_cast<const CEvaluationNodeNumber*>(pChild2);
                    assert(pNumberNode2 != NULL);
                    os << ((int)pNumberNode1->getValue()) % ((int)pNumberNode2->getValue());
                    pTmpOrig = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str());

                    // now we need to replace dfi in it's parent by pTmpOrig and
                    // delete dfi
                    if (dfi->getParent() != NULL)
                      {
                        dfi->getParent()->addChild(pTmpOrig, *dfi);
                        dfi->getParent()->removeChild(*dfi);
                        delete *dfi;
                        dfi = pTmpOrig;
                      }
                    else
                      {
                        // it must be the root node
                        assert(*dfi == pResult);
                        delete pResult;
                        pResult = pTmpOrig;
                        // we are done
                        dfi = NULL;

                      }

                    modified = true;
                  }

                break;
              case CEvaluationNodeOperator::MULTIPLY:
              case CEvaluationNodeOperator::DIVIDE:
              {
                pTmpOrig = dynamic_cast<CEvaluationNode*>(dfi->getParent());

                // if there is no parent or if the parent is not a multiplication or division, we try to evaluate numbers
                if (pTmpOrig == NULL || type != CEvaluationNode::OPERATOR || (((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pTmpOrig->getType())) != CEvaluationNodeOperator::MULTIPLY && ((CEvaluationNodeOperator::SubType)CEvaluationNode::subType(pTmpOrig->getType())) != CEvaluationNodeOperator::DIVIDE))
                  {

                    std::vector<const CEvaluationNode*> multiplications, divisions;
                    // multiplications and divisions contain the original nodes,
                    // splitProduct doesn't copy nodes
                    CNormalTranslation::splitProduct(*dfi, multiplications, divisions, false);
                    std::set<CEvaluationNode*> multiplicationNumberNodes;
                    unsigned int i, iMax = multiplications.size();
                    CEvaluationNode* pNode = NULL;

                    for (i = 0; i < iMax; ++i)
                      {
                        pNode = const_cast<CEvaluationNode*>(multiplications[i]);

                        if (CEvaluationNode::type(pNode->getType()) == CEvaluationNode::NUMBER)
                          {
                            multiplicationNumberNodes.insert(pNode);
                          }
                      }

                    std::set<CEvaluationNode*> divisionNumberNodes;
                    iMax = divisions.size();

                    for (i = 0; i < iMax; ++i)
                      {
                        pNode = const_cast<CEvaluationNode*>(divisions[i]);

                        if (CEvaluationNode::type(pNode->getType()) == CEvaluationNode::NUMBER)
                          {
                            divisionNumberNodes.insert(pNode);
                          }
                      }

                    if ((multiplicationNumberNodes.size() + divisionNumberNodes.size()) > 1)
                      {
                        // there are at least two number nodes, so we have to evaluate
                        // the numbers
                        double value = 1.0;
                        std::set<CEvaluationNode*>::iterator it = multiplicationNumberNodes.begin(), endit = multiplicationNumberNodes.end();

                        while (it != endit)
                          {
                            value *= (*it)->getValue();
                            ++it;
                          }

                        it = divisionNumberNodes.begin();
                        endit = divisionNumberNodes.end();

                        while (it != endit)
                          {
                            value /= (*it)->getValue();
                            ++it;
                          }

                        std::vector<CEvaluationNode*> newMultiplications, newDivisions;

                        if (fabs((value - 1.0)) >= ZERO)
                          {
                            std::ostringstream os;
                            os.precision(18);

                            if (fabs(value) < 1.0)
                              {
                                os << 1.0 / value;
                                CEvaluationNodeNumber* pEvaluated = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str());
                                newDivisions.push_back(pEvaluated);
                              }
                            else
                              {
                                os << value;
                                CEvaluationNodeNumber* pEvaluated = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str());
                                newMultiplications.push_back(pEvaluated);
                              }
                          }

                        std::vector<const CEvaluationNode*>::iterator it2 = multiplications.begin(), endit2 = multiplications.end();

                        while (it2 != endit2)
                          {
                            // if the node is not in multiplicationNumberNodes, we add
                            // it
                            it = multiplicationNumberNodes.find(const_cast<CEvaluationNode*>(*it2));

                            if (it == multiplicationNumberNodes.end())
                              {

                                CEvaluationNode* pTmpNode = const_cast<CEvaluationNode*>(*it2);

                                // to reuse the nodes, we have to remove them from their original parent
                                if (pTmpNode->getParent() != NULL)
                                  {
                                    pTmpNode->getParent()->removeChild(pTmpNode);
                                  }

                                newMultiplications.push_back(pTmpNode);
                              }
                            else
                              {
                                // delete the old number node
                                delete *it2;
                              }

                            ++it2;
                          }

                        it2 = divisions.begin();
                        endit2 = divisions.end();

                        while (it2 != endit2)
                          {
                            // if the node is not in multiplicationNumberNodes, we add
                            // it
                            it = divisionNumberNodes.find(const_cast<CEvaluationNode*>(*it2));

                            if (it == divisionNumberNodes.end())
                              {
                                CEvaluationNode* pTmpNode = const_cast<CEvaluationNode*>(*it2);

                                // to reuse the nodes, we have to remove them from their original parent
                                if (pTmpNode->getParent() != NULL)
                                  {
                                    pTmpNode->getParent()->removeChild(pTmpNode);
                                  }

                                newDivisions.push_back(const_cast<CEvaluationNode*>(pTmpNode));
                              }
                            else
                              {
                                // delete the old number node
                                delete *it2;
                              }

                            ++it2;
                          }

                        // now we create a new result node from the newMultiplications
                        // and newDivisions
                        if (newMultiplications.empty())
                          {
                            pTmpOrig = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, "1.0");
                          }
                        else
                          {
                            pTmpOrig = CNormalTranslation::createChain(&CNormalTranslation::TIMES_NODE, &CNormalTranslation::ONE_NODE, newMultiplications);
                          }

                        if (!newDivisions.empty())
                          {
                            CEvaluationNode* pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE, "/");
                            pTmpNode->addChild(pTmpOrig);
                            pTmpOrig = pTmpNode;
                            pTmpNode = CNormalTranslation::createChain(&CNormalTranslation::TIMES_NODE, &CNormalTranslation::ONE_NODE, newDivisions);
                            pTmpOrig->addChild(pTmpNode);
                          }

                        // now we need to replace dfi in it's parent by pTmpOrig and
                        // delete dfi
                        if (dfi->getParent() != NULL)
                          {
                            dfi->getParent()->addChild(pTmpOrig, *dfi);
                            dfi->getParent()->removeChild(*dfi);
                            delete *dfi;
                            dfi = pTmpOrig;
                          }
                        else
                          {
                            // it must be the root node
                            assert(*dfi == pResult);
                            delete pResult;
                            pResult = pTmpOrig;
                            // we are done
                            dfi = NULL;
                          }

                        modified = true;

                      }
                  }
              }
              break;
              case CEvaluationNodeOperator::PLUS:
              case CEvaluationNodeOperator::MINUS:
              {
                pTmpOrig = dynamic_cast<CEvaluationNode*>(dfi->getParent());

                // if there is no parent or if the parent is not a multiplication or division, we try to evaluate numbers
                if (pTmpOrig == NULL || type != CEvaluationNode::OPERATOR || ((((CEvaluationNodeOperator::SubType)CEvaluationNodeOperator::subType(pTmpOrig->getType())) != CEvaluationNodeOperator::PLUS && ((CEvaluationNodeOperator::SubType)CEvaluationNodeOperator::subType(pTmpOrig->getType())) != CEvaluationNodeOperator::MINUS)))
                  {
                    std::vector<CEvaluationNode*> additions, subtractions;
                    // splitSum copies the nodes that are returned
                    CNormalTranslation::splitSum(*dfi, additions, subtractions, false);
                    CNormalTranslation::swapNegativeNumbers(additions, subtractions);
                    std::set<CEvaluationNode*> additionNumberNodes;
                    unsigned int i, iMax = additions.size();
                    CEvaluationNode* pNode = NULL;

                    for (i = 0; i < iMax; ++i)
                      {
                        pNode = const_cast<CEvaluationNode*>(additions[i]);

                        if (CEvaluationNode::type(pNode->getType()) == CEvaluationNode::NUMBER)
                          {
                            additionNumberNodes.insert(pNode);
                          }
                      }

                    std::set<CEvaluationNode*> subtractionNumberNodes;
                    iMax = subtractions.size();

                    for (i = 0; i < iMax; ++i)
                      {
                        pNode = const_cast<CEvaluationNode*>(subtractions[i]);

                        if (CEvaluationNode::type(pNode->getType()) == CEvaluationNode::NUMBER)
                          {
                            subtractionNumberNodes.insert(pNode);
                          }
                      }

                    if ((additionNumberNodes.size() + subtractionNumberNodes.size()) > 1)
                      {
                        // there are at least two number nodes, so we have to evaluate
                        // the numbers
                        double value = 0.0;
                        std::set<CEvaluationNode*>::const_iterator it = additionNumberNodes.begin(), endit = additionNumberNodes.end();

                        while (it != endit)
                          {
                            value += (*it)->getValue();
                            ++it;
                          }

                        it = subtractionNumberNodes.begin();
                        endit = subtractionNumberNodes.end();

                        while (it != endit)
                          {
                            value -= (*it)->getValue();
                            ++it;
                          }

                        std::vector<CEvaluationNode*> newAdditions, newSubtractions;

                        if (fabs(value) >= ZERO)
                          {
                            std::ostringstream os;
                            os.precision(18);

                            if (value < 0.0)
                              {
                                os << -1.0 * value;
                                CEvaluationNodeNumber* pEvaluated = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str());
                                newSubtractions.push_back(pEvaluated);
                              }
                            else
                              {
                                os << value;
                                CEvaluationNodeNumber* pEvaluated = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str().c_str());
                                newAdditions.push_back(pEvaluated);
                              }
                          }

                        // now we have to copy all nonnumber nodes
                        std::vector<CEvaluationNode*>::const_iterator it2 = additions.begin(), endit2 = additions.end();

                        while (it2 != endit2)
                          {
                            // if the node is not in additionNumberNodes, we copy
                            // it
                            it = additionNumberNodes.find(*it2);

                            if (it == additionNumberNodes.end())
                              {
                                newAdditions.push_back(*it2);
                              }
                            else
                              {
                                // delete the original node that was created by splitSum
                                delete *it2;
                              }

                            ++it2;
                          }

                        it2 = subtractions.begin();
                        endit2 = subtractions.end();

                        while (it2 != endit2)
                          {
                            // if the node is not in subtractionNumberNodes, we copy
                            // it
                            it = subtractionNumberNodes.find(*it2);

                            if (it == subtractionNumberNodes.end())
                              {
                                newSubtractions.push_back(*it2);
                              }
                            else
                              {
                                // delete the original node that was created by splitSum
                                delete *it2;
                              }