compute.cpp

Go to the documentation of this file.

#include <cmath>
#include <iostream>
#include <vector>

#include "popassert.h"
#include "CVector3f.h"
#include "compute.h"





/*****************************************\
 *                                       *
 *  Beginning of the creator functions.  *
 *                                       *
\*****************************************/


CValue* CValue::GetNewAddition(CValue* pLeftOperand, CValue* pRightOperand)
{
  POP_ASSERT(pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(pRightOperand != NULL, "Using a NULL pointer");

  float Number1, Number2;
  if (pLeftOperand->IsConstant(&Number1) &&
      pRightOperand->IsConstant(&Number2))
    {
      Number1 += Number2;
      delete pLeftOperand;
      delete pRightOperand;
      return new CNumber(Number1);
    }

  // One bit for left value and the other one for right value
  switch ( (pLeftOperand->IsAddNeutralElem() << 1) +
           (pRightOperand->IsAddNeutralElem() << 0) )
    {
    case ( (0 << 1) + (0 << 0) ):
      return (new CAddition(pLeftOperand, pRightOperand));
      break;
    case ( (1 << 1) + (0 << 0) ):
      delete pLeftOperand;
      return pRightOperand;
      break;
    case ( (0 << 1) + (1 << 0) ):
      delete pRightOperand;
      return pLeftOperand;
      break;
    default:
      // Should not happen
      POP_ILLEGAL("Should not get here");
      return NULL;
      break;
    }
}


CValue* CValue::GetNewSubstraction(CValue* pLeftOperand, CValue* pRightOperand)
{
  POP_ASSERT(pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(pRightOperand != NULL, "Using a NULL pointer");

  float Number1, Number2;
  if (pLeftOperand->IsConstant(&Number1) &&
      pRightOperand->IsConstant(&Number2))
    {
      Number1 -= Number2;
      delete pLeftOperand;
      delete pRightOperand;
      return (new CNumber(Number1));
    }

  // One bit for left value and the other one for right value
  switch ( (pLeftOperand->IsAddNeutralElem() << 1) +
           (pRightOperand->IsAddNeutralElem() << 0) )
    {
    case ( (0 << 1) + (0 << 0) ):
      return (new CSubstraction(pLeftOperand, pRightOperand));
      break;
    case ( (1 << 1) + (0 << 0) ):
      delete pLeftOperand;
      return (new COpposite(pRightOperand));
      break;
    case ( (0 << 1) + (1 << 0) ):
      delete pRightOperand;
      return pLeftOperand;
      break;
    default:
      // Should not happen
      POP_ILLEGAL("Should not get here");
      return NULL;
      break;
    }
}


CValue* CValue::GetNewProduct(CValue* pLeftOperand, CValue* pRightOperand)
{
  POP_ASSERT(pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(pRightOperand != NULL, "Using a NULL pointer");

  float Number1, Number2;
  if (pLeftOperand->IsConstant(&Number1)
      && pRightOperand->IsConstant(&Number2))
    {
      Number1 *= Number2;
      delete pLeftOperand;
      delete pRightOperand;
      return (new CNumber(Number1));
    }

  // One bit for left value and the other one for right value
  switch ( (pLeftOperand->IsConstant() << 1) +
           (pRightOperand->IsConstant() << 0) )
    {
    case ( (0 << 1) + (0 << 1) ):
      return (new CProduct(pLeftOperand, pRightOperand));
      break;
    case ( (1 << 1) + (0 << 0) ):
      if ( pLeftOperand->IsMultAbsorbElem() )
        {
          delete pLeftOperand;
          delete pRightOperand;
          return (new CNumber(0));
        }
      else if (pLeftOperand->IsMultNeutralElem())
        {
          delete pLeftOperand;
          return pRightOperand;
        }
      else
        {
          return (new CProduct(pLeftOperand, pRightOperand));
        }
      break;
    case ( (0 << 1) + (1 << 0) ):
      if ( pRightOperand->IsMultAbsorbElem() )
        {
          delete pLeftOperand;
          delete pRightOperand;
          return (new CNumber(0));
        }
      else if (pRightOperand->IsMultNeutralElem())
        {
          delete pRightOperand;
          return pLeftOperand;
        }
      else
        {
          return (new CProduct(pLeftOperand, pRightOperand));
        }
      break;
    default:
      // Should not happen
      POP_ILLEGAL("Should not get here");
      return NULL;
      break;
    }
}


CValue* CValue::GetNewDivision(CValue* pLeftOperand, CValue* pRightOperand)
{
  POP_ASSERT(pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(pRightOperand != NULL, "Using a NULL pointer");

  float Number1, Number2;
  if (pLeftOperand->IsConstant(&Number1) &&
      pRightOperand->IsConstant(&Number2))
    {
      if (Number2 == 0)
        throw;

      Number1 /= Number2;
      delete pLeftOperand;
      delete pRightOperand;
      return (new CNumber(Number1));
    }

  // One bit for left value and the other one for right value
  switch ( (pLeftOperand->IsConstant() << 1) +
           (pRightOperand->IsConstant() << 0) )
    {
    case ( (0 << 1) + (0 << 1) ):
      return (new CDivision(pLeftOperand, pRightOperand));
      break;
    case ( (1 << 1) + (0 << 0) ):
      if ( pLeftOperand->IsMultAbsorbElem() )
        {
          delete pLeftOperand;
          delete pRightOperand;
          return (new CNumber(0));
        }
      else
        {
          return (new CDivision(pLeftOperand, pRightOperand));
        }
      break;
    case ( (0 << 1) + (1 << 0) ):
      if ( pRightOperand->IsMultAbsorbElem() )
        {
          throw;
        }
      else if (pRightOperand->IsMultNeutralElem())
        {
          delete pRightOperand;
          return pLeftOperand;
        }
      else
        {
          return (new CDivision(pLeftOperand, pRightOperand));
        }
      break;
    default:
      // Should not happen
      POP_ILLEGAL("Should not get here");
      return NULL;
      break;
    }
}


CValue* CValue::GetNewOpposite(CValue* pLeftOperand)
{
  POP_ASSERT(pLeftOperand != NULL, "Using a NULL pointer");

  float Number;
  if (pLeftOperand->IsConstant(&Number))
    {
      delete pLeftOperand;
      return (new CNumber(-Number));
    }
  else
    {
      return (new COpposite(pLeftOperand) );
    }
}

CValue* CValue::GetNewSqrt(CValue* pLeftOperand)
{
  POP_ASSERT(pLeftOperand != NULL, "Using a NULL pointer");

  float Number;
  if (pLeftOperand->IsConstant(&Number))
    {
      delete pLeftOperand;

      if (Number < 0)
        throw;

      return (new CNumber(sqrtf(Number)));
    }
  else
    {
      return (new CSqrt(pLeftOperand));
    }
}

CValue* CValue::GetNewSin(CValue* pLeftOperand)
{
  POP_ASSERT(pLeftOperand != NULL, "Using a NULL pointer");

  float Number;
  if (pLeftOperand->IsConstant(&Number))
    {
      delete pLeftOperand;
      return (new CNumber(sinf(Number)));
    }
  else
    {
      return (new CSin(pLeftOperand) );
    }
}

CValue* CValue::GetNewCos(CValue* pLeftOperand)
{
  POP_ASSERT(pLeftOperand != NULL, "Using a NULL pointer");

  float Number;
  if (pLeftOperand->IsConstant(&Number))
    {
      delete pLeftOperand;
      return (new CNumber(cosf(Number)));
    }
  else
    {
      return (new CCos(pLeftOperand) );
    }
}

CValue* CValue::GetNewTan(CValue* pLeftOperand)
{
  POP_ASSERT(pLeftOperand != NULL, "Using a NULL pointer");

  float Number;
  if (pLeftOperand->IsConstant(&Number))
    {
      delete pLeftOperand;
      return (new CNumber(tanf(Number)));
    }
  else
    {
      return (new CTan(pLeftOperand) );
    }
}

CValue* CValue::GetNewExp(CValue* pLeftOperand)
{
  POP_ASSERT(pLeftOperand != NULL, "Using a NULL pointer");

  float Number;
  if (pLeftOperand->IsConstant(&Number))
    {
      delete pLeftOperand;
      return (new CNumber(expf(Number)));
    }
  else
    {
      return (new CExp(pLeftOperand) );
    }
}

CValue* CValue::GetNewLn(CValue* pLeftOperand)
{
  POP_ASSERT(pLeftOperand != NULL, "Using a NULL pointer");

  float Number;
  if (pLeftOperand->IsConstant(&Number))
    {
      delete pLeftOperand;
      return (new CNumber(logf(Number)));
    }
  else
    {
      return (new CLn(pLeftOperand) );
    }
}

CValue* CValue::GetNewPow(CValue* pLeftOperand, CValue* pRightOperand)
{
  POP_ASSERT(pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(pRightOperand != NULL, "Using a NULL pointer");

  float Number1, Number2;
  if (pLeftOperand->IsConstant(&Number1) &&
      pRightOperand->IsConstant(&Number2))
    {
      if (Number1 == 0 && Number2 == 0)
        {
          throw;
        }

      Number1 = pow(Number1, Number2);
      delete pLeftOperand;
      delete pRightOperand;
      // Check for NaN
      if ( Number1 == Number1 )
        {
          return (new CNumber(Number1));
        }
      else
        {
          throw;
          return NULL;
        }
    }

  // One bit for left value and the other one for right value
  switch ( (pLeftOperand->IsConstant() << 1) +
           (pRightOperand->IsConstant() << 0) )
    {
    case ( (0 << 1) + (0 << 1) ):
      return (new CPow(pLeftOperand, pRightOperand));
      break;
    case ( (1 << 1) + (0 << 0) ):
      if ( pLeftOperand->IsMultAbsorbElem() )
        {
          delete pLeftOperand;
          delete pRightOperand;
          return new CNumber(0);
        }
      else if ( pLeftOperand->IsMultNeutralElem() )
        {
          delete pLeftOperand;
          delete pRightOperand;
          return (new CNumber(1));
        }
      else
        {
          return (new CPow(pLeftOperand, pRightOperand));
        }
      break;
    case ( (0 << 1) + (1 << 0) ):
      if ( pRightOperand->IsMultAbsorbElem() )
        {
          delete pRightOperand;
          return pLeftOperand;
          return (new CNumber(1));
        }
      else if ( pRightOperand->IsMultNeutralElem() )
        {
          delete pRightOperand;
          return (pLeftOperand);
        }
      else
        {
          return (new CPow(pLeftOperand, pRightOperand));
        }
      break;
    default:
      // Should not happen
      POP_ILLEGAL("Should not get here");
      return NULL;
      break;
    }
}





/***********************************\
 *                                 *
 *  Beginning of the constructors  *
 *                                 *
\***********************************/

CAddition::CAddition(CValue* pLeftOperand, CValue* pRightOperand)
  : COperation(pLeftOperand, pRightOperand)
{
}

CSubstraction::CSubstraction(CValue* pLeftOperand, CValue* pRightOperand)
  : COperation(pLeftOperand, pRightOperand)
{
}

CProduct::CProduct(CValue* pLeftOperand, CValue* pRightOperand)
  : COperation(pLeftOperand, pRightOperand)
{
}

CDivision::CDivision(CValue* pLeftOperand, CValue* pRightOperand)
  : COperation(pLeftOperand, pRightOperand)
{
}

COpposite::COpposite(CValue* pLeftOperand)
  : COperation(pLeftOperand, NULL)
{
}

CSqrt::CSqrt(CValue* pLeftOperand)
  : COperation(pLeftOperand, NULL)
{
}

CSin::CSin(CValue* pLeftOperand)
  : COperation(pLeftOperand, NULL)
{
}

CCos::CCos(CValue* pLeftOperand)
  : COperation(pLeftOperand, NULL)
{
}

CTan::CTan(CValue* pLeftOperand)
  : COperation(pLeftOperand, NULL)
{
}

CExp::CExp(CValue* pLeftOperand)
  : COperation(pLeftOperand, NULL)
{
}

CLn::CLn(CValue* pLeftOperand)
  : COperation(pLeftOperand, NULL)
{
}

CPow::CPow(CValue* pLeftOperand, CValue* pRightOperand)
  : COperation(pLeftOperand, pRightOperand)
{
}

CVariable::CVariable(TYPE_VARIABLE Type)
{
  m_Type = Type;
}

CNumber::CNumber(float Number)
{
  m_Number = Number;
}




/******************************************\
 *                                        *
 *  Beginning of the GetCopy() functions  *
 *                                        *
\******************************************/

CValue* CAddition::GetCopy() const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  return new CAddition(m_pLeftOperand->GetCopy(), m_pRightOperand->GetCopy());
}

CValue* CSubstraction::GetCopy() const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  return new CSubstraction(m_pLeftOperand->GetCopy(),
                           m_pRightOperand->GetCopy());
}

CValue* CProduct::GetCopy() const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  return new CProduct(m_pLeftOperand->GetCopy(), m_pRightOperand->GetCopy());
}

CValue* CDivision::GetCopy() const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  return new CDivision(m_pLeftOperand->GetCopy(), m_pRightOperand->GetCopy());
}

CValue* COpposite::GetCopy() const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return new COpposite(m_pLeftOperand->GetCopy());
}

CValue* CSqrt::GetCopy() const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return new CSqrt(m_pLeftOperand->GetCopy());
}

CValue* CSin::GetCopy() const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return new CSin(m_pLeftOperand->GetCopy());
}

CValue* CCos::GetCopy() const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return new CCos(m_pLeftOperand->GetCopy());
}

CValue* CTan::GetCopy() const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return new CTan(m_pLeftOperand->GetCopy());
}

CValue* CExp::GetCopy() const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return new CExp(m_pLeftOperand->GetCopy());
}

CValue* CLn::GetCopy() const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return new CLn(m_pLeftOperand->GetCopy());
}

CValue* CPow::GetCopy() const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  return new CPow(m_pLeftOperand->GetCopy(), m_pRightOperand->GetCopy());
}

CValue* CVariable::GetCopy() const
{
  return new CVariable(m_Type);
}

CValue* CNumber::GetCopy() const
{
  return new CNumber(m_Number);
}




/******************************************\
 *                                        *
 *  Beginning of the Compute() functions  *
 *                                        *
\******************************************/

float CAddition::Compute(const CVector3f& Point) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  return (m_pLeftOperand->Compute(Point) + m_pRightOperand->Compute(Point));
}

float CSubstraction::Compute(const CVector3f& Point) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  return (m_pLeftOperand->Compute(Point) - m_pRightOperand->Compute(Point));
}

float CProduct::Compute(const CVector3f& Point) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  return (m_pLeftOperand->Compute(Point) * m_pRightOperand->Compute(Point));
}

float CDivision::Compute(const CVector3f& Point) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  return (m_pLeftOperand->Compute(Point) / m_pRightOperand->Compute(Point));
}

float COpposite::Compute(const CVector3f& Point) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return (-(m_pLeftOperand->Compute(Point)));
}

float CSqrt::Compute(const CVector3f& Point) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return (sqrtf(m_pLeftOperand->Compute(Point)));
}

float CSin::Compute(const CVector3f& Point) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return (sinf(m_pLeftOperand->Compute(Point)));
}

float CCos::Compute(const CVector3f& Point) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return (cosf(m_pLeftOperand->Compute(Point)));
}

float CTan::Compute(const CVector3f& Point) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return (tanf(m_pLeftOperand->Compute(Point)));
}

float CExp::Compute(const CVector3f& Point) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return (expf(m_pLeftOperand->Compute(Point)));
}

float CLn::Compute(const CVector3f& Point) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return (logf(m_pLeftOperand->Compute(Point)));
}

float CPow::Compute(const CVector3f& Point) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  return (powf(m_pLeftOperand->Compute(Point), m_pRightOperand->Compute(Point)));
}

float CVariable::Compute(const CVector3f& Point) const
{
  switch (m_Type)
    {
    case (TYPE_X): return Point.x; break;
    case (TYPE_Y): return Point.y; break;
    case (TYPE_Z): return Point.z; break;
    default: POP_ILLEGAL("Should not get here"); return 0; break;
    }
}

float CNumber::Compute(const CVector3f& Point) const
{
  return m_Number;
}





/*****************************************\
 *                                       *
 *  Beginning of the Derive() functions  *
 *                                       *
\*****************************************/

CValue* CAddition::Derive(TYPE_VARIABLE Type) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  return GetNewAddition(m_pLeftOperand->Derive(Type),
                        m_pRightOperand->Derive(Type));
}

CValue* CSubstraction::Derive(TYPE_VARIABLE Type) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  return GetNewSubstraction(m_pLeftOperand->Derive(Type),
                            m_pRightOperand->Derive(Type));
}

CValue* CProduct::Derive(TYPE_VARIABLE Type) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  return GetNewAddition(GetNewProduct(m_pLeftOperand->Derive(Type),
                                      m_pRightOperand->GetCopy()),
                        GetNewProduct(m_pLeftOperand->GetCopy(),
                                      m_pRightOperand->Derive(Type)));
}

CValue* CDivision::Derive(TYPE_VARIABLE Type) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  CValue* Numerator =
    GetNewSubstraction(
                       GetNewProduct(m_pLeftOperand->Derive(Type),
                                     m_pRightOperand->GetCopy()),
                       GetNewProduct(m_pLeftOperand->GetCopy(),
                                     m_pRightOperand->Derive(Type))
                       );

  CValue* Denominator = GetNewPow(m_pRightOperand->GetCopy(), new CNumber(2));

  return GetNewDivision(Numerator, Denominator);
}

CValue* COpposite::Derive(TYPE_VARIABLE Type) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return GetNewOpposite(m_pLeftOperand->Derive(Type));
}

CValue* CSqrt::Derive(TYPE_VARIABLE Type) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return GetNewDivision( m_pLeftOperand->Derive(Type),
                         GetNewProduct(new CNumber(2),
                                       GetNewSqrt(m_pLeftOperand->GetCopy())));
}

CValue* CSin::Derive(TYPE_VARIABLE Type) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return GetNewProduct(GetNewCos(m_pLeftOperand->GetCopy()),
                       m_pLeftOperand->Derive(Type));
}

CValue* CCos::Derive(TYPE_VARIABLE Type) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return GetNewProduct(GetNewOpposite(GetNewSin(m_pLeftOperand->GetCopy())),
                       m_pLeftOperand->Derive(Type));
}

CValue* CTan::Derive(TYPE_VARIABLE Type) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return GetNewDivision(m_pLeftOperand->Derive(Type),
                        GetNewPow(GetNewCos(m_pLeftOperand->GetCopy()),
                                  new CNumber(2)));
}

CValue* CExp::Derive(TYPE_VARIABLE Type) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return GetNewProduct(GetNewExp(m_pLeftOperand->GetCopy()),
                       m_pLeftOperand->Derive(Type));
}

CValue* CPow::Derive(TYPE_VARIABLE Type) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  float Number;
  if (m_pRightOperand->IsConstant(&Number))
    {
      return GetNewProduct(GetNewProduct(new CNumber(Number), 
                                         m_pLeftOperand->Derive(Type)),
                           GetNewPow(m_pLeftOperand->GetCopy(),
                                     new CNumber(Number - 1)));
    }
  else
    {
      // Left part of the parenthesis
      CValue* pLeftOperand =
        GetNewProduct(m_pRightOperand->Derive(Type),
                      GetNewLn(m_pLeftOperand->GetCopy()));

      // Right part of the parenthesis
      CValue* pRightOperand =
        GetNewDivision(GetNewProduct(m_pRightOperand->GetCopy(),
                                     m_pLeftOperand->Derive(Type)),
                       m_pLeftOperand->GetCopy());

      return GetNewProduct(this->GetCopy(),
                           GetNewAddition(pLeftOperand, pRightOperand));
    }
}

CValue* CLn::Derive(TYPE_VARIABLE Type) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  return GetNewDivision(m_pLeftOperand->Derive(Type), m_pLeftOperand->GetCopy());
}

CValue* CVariable::Derive(TYPE_VARIABLE Type) const
{
  if (Type == m_Type)
    return new CNumber(1);
  else
    return new CNumber(0);
}

CValue* CNumber::Derive(TYPE_VARIABLE Type) const
{
  return new CNumber(0);
}





/****************************************\
 *                                      *
 *  Beginning of the Print() functions  *
 *                                      *
\****************************************/

void CAddition::Print(std::ostream& o) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  o << '(';
  m_pLeftOperand->Print(o);
  o << '+';
  m_pRightOperand->Print(o);
  o << ')';
}

void CSubstraction::Print(std::ostream& o) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  o << '(';
  m_pLeftOperand->Print(o);
  o << '-';
  m_pRightOperand->Print(o);
  o << ')';
}

void CProduct::Print(std::ostream& o) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  o << '(';
  m_pLeftOperand->Print(o);
  o << '*';
  m_pRightOperand->Print(o);
  o << ')';
}

void CDivision::Print(std::ostream& o) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  o << '(';
  m_pLeftOperand->Print(o);
  o << '/';
  m_pRightOperand->Print(o);
  o << ')';
}

void COpposite::Print(std::ostream& o) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  o << "(-";
  m_pLeftOperand->Print(o);
  o << ')';
}

void CSqrt::Print(std::ostream& o) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  o << "sqrt(";
  m_pLeftOperand->Print(o);
  o << ')';
}

void CSin::Print(std::ostream& o) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  o << "sin(";
  m_pLeftOperand->Print(o);
  o << ')';
}

void CCos::Print(std::ostream& o) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  o << "cos(";
  m_pLeftOperand->Print(o);
  o << ')';
}

void CTan::Print(std::ostream& o) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  o << "tan(";
  m_pLeftOperand->Print(o);
  o << ')';
}

void CExp::Print(std::ostream& o) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  o << "exp(";
  m_pLeftOperand->Print(o);
  o << ')';
}

void CLn::Print(std::ostream& o) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  o << "ln(";
  m_pLeftOperand->Print(o);
  o << ')';
}

void CPow::Print(std::ostream& o) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  m_pLeftOperand->Print(o);
  o << '^';
  m_pRightOperand->Print(o);
}

void CVariable::Print(std::ostream& o) const
{
  switch (m_Type)
    {
    case (TYPE_X): o << 'x'; break;
    case (TYPE_Y): o << 'y'; break;
    case (TYPE_Z): o << 'z'; break;
    default: POP_ILLEGAL("Should not get here"); break;
    }
}

void CNumber::Print(std::ostream& o) const
{
  o << m_Number;
}





inline void BEFORE_PUSH(std::vector<char>& v, int& i)
{
  ++i;

  if (i > 8)
    {
      v.push_back('\xd9');
      v.push_back('\xf6'); // fdecstp

      v.push_back('\x83');
      v.push_back('\xec');
      v.push_back('\x04'); // subl   $4,%esp

      v.push_back('\xd9');
      v.push_back('\x14');
      v.push_back('\x24'); // fsts   (%esp)

      v.push_back('\xdd');
      v.push_back('\xc0'); // ffree  %st(0)

      v.push_back('\xd9');
      v.push_back('\xf7'); // fincstp
    }
}

inline void AFTER_POP(std::vector<char>& v, int& i)
{
  if (i > 8)
    {
      v.push_back('\xd9');
      v.push_back('\x04');
      v.push_back('\x24'); // flds   (%esp)

      v.push_back('\xd9');
      v.push_back('\xf7'); // fincstp

      v.push_back('\x83');
      v.push_back('\xc4');
      v.push_back('\x04'); // addl   $4,%esp
    }

  --i;
}

/******************************************\
 *                                        *
 *  Beginning of the Compile() functions  *
 *                                        *
\******************************************/

void CAddition::Compile(std::vector<char>& v, int& i) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  m_pLeftOperand->Compile(v, i);
  m_pRightOperand->Compile(v, i);

  v.push_back('\xde');
  v.push_back('\xc1'); // faddp

  AFTER_POP(v, i);
}


void CSubstraction::Compile(std::vector<char>& v, int& i) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  m_pLeftOperand->Compile(v, i);
  m_pRightOperand->Compile(v, i);

  v.push_back('\xde');
  v.push_back('\xe9'); // fsubrp

  AFTER_POP(v, i);
}

void CProduct::Compile(std::vector<char>& v, int& i) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  m_pLeftOperand->Compile(v, i);
  m_pRightOperand->Compile(v, i);

  v.push_back('\xde');
  v.push_back('\xc9'); // fmulp

  AFTER_POP(v, i);
}

void CDivision::Compile(std::vector<char>& v, int& i) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  m_pLeftOperand->Compile(v, i);
  m_pRightOperand->Compile(v, i);

  v.push_back('\xde');
  v.push_back('\xf9'); // fdivrp

  AFTER_POP(v, i);
}

void COpposite::Compile(std::vector<char>& v, int& i) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  m_pLeftOperand->Compile(v, i);

  v.push_back('\xd9');
  v.push_back('\xe0'); // fdivrp
}

void CSqrt::Compile(std::vector<char>& v, int& i) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  m_pLeftOperand->Compile(v, i);

  v.push_back('\xd9');
  v.push_back('\xfa'); // fsqrt
}

void CSin::Compile(std::vector<char>& v, int& i) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  m_pLeftOperand->Compile(v, i);

  v.push_back('\xd9');
  v.push_back('\xfe'); // fsin
}

void CCos::Compile(std::vector<char>& v, int& i) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  m_pLeftOperand->Compile(v, i);

  v.push_back('\xd9');
  v.push_back('\xff'); // fcos
}

void CTan::Compile(std::vector<char>& v, int& i) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  m_pLeftOperand->Compile(v, i);

  BEFORE_PUSH(v, i);

  v.push_back('\xd9');
  v.push_back('\xf2'); // fptan

  v.push_back('\xdd');
  v.push_back('\xc0'); // ffree  %st(0)

  v.push_back('\xd9');
  v.push_back('\xf7'); // fincstp

  AFTER_POP(v, i);
}

void CExp::Compile(std::vector<char>& v, int& i) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  m_pLeftOperand->Compile(v, i);

  // compute e^b
  // on stack => b

  BEFORE_PUSH(v, i);

  v.push_back('\xd9');
  v.push_back('\xea'); // fldl2e
  // on stack => log2(e) : b

  v.push_back('\xde');
  v.push_back('\xc9'); // fmulp
  // on stack => b*log2(e)

  v.push_back('\xd9');
  v.push_back('\xe8'); // fld1
  // on stack => 1 : b*log2(e)

  BEFORE_PUSH(v, i);

  v.push_back('\xd9');
  v.push_back('\xc1'); // fld     %st(1)
  // on stack => b*log2(e) : 1 : b*log2(e)

  v.push_back('\xd9');
  v.push_back('\xfc'); // frndint
  // on stack => int(b*log2(e)) : 1 : b*log2(e)

  v.push_back('\xd9');
  v.push_back('\xca'); // fxch    %st(2)
  // on stack => b*log2(e) : 1 : int(b*log2(e))

  v.push_back('\xd8');
  v.push_back('\xe2'); // fsub    %st(2),%st
  // on stack => frac(b*log2(e)) : 1 : int(b*log2(e))

  v.push_back('\xd9');
  v.push_back('\xf0'); // f2xm1
  // on stack => 2^frac(b*log2(e))-1 : 1 : int(b*log2(e))

  v.push_back('\xde');
  v.push_back('\xc1'); // faddp   %st,%st(1)
  // on stack => 2^frac(b*log2(e)) : int(b*log2(e))

  AFTER_POP(v, i);

  // 2^frac(b*log2(e))*2^int(b*log2(e))=2^(b*log2(e))=e^b

  v.push_back('\xd9');
  v.push_back('\xfd'); // fscale
  // on stack => e^b : int(b*log2(e))

  v.push_back('\xd9');
  v.push_back('\xc9'); // fxch
  // on stack => int(b*log2(e)) : e^b


  v.push_back('\xdd');
  v.push_back('\xc0'); // ffree  %st(0)

  v.push_back('\xd9');
  v.push_back('\xf7'); // fincstp
  // on stack => e^b

  AFTER_POP(v, i);
}

void CLn::Compile(std::vector<char>& v, int& i) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");

  m_pLeftOperand->Compile(v, i);

  // compute ln(x)
  // on stack => x

  BEFORE_PUSH(v, i);

  v.push_back('\xd9');
  v.push_back('\xe8'); // fld1
  // on stack => 1 : x

  BEFORE_PUSH(v, i);

  v.push_back('\xd9');
  v.push_back('\xea'); // fldl2e
  // on stack => log2(e) : 1 : x

  v.push_back('\xd9');
  v.push_back('\xca'); // fxch    %st(2)
  // on stack => x : 1 : log2(e)

  v.push_back('\xd9');
  v.push_back('\xf1'); // fyl2x
  // on stack => 1*log2(x) : log2(e)

  AFTER_POP(v, i);

  v.push_back('\xde');
  v.push_back('\xf1'); // fdivp
  // on stack => log2(x) / log2(e) = ln(x)

  AFTER_POP(v, i);
}

void CPow::Compile(std::vector<char>& v, int& i) const
{
  POP_ASSERT(m_pLeftOperand != NULL, "Using a NULL pointer");
  POP_ASSERT(m_pRightOperand != NULL, "Using a NULL pointer");

  m_pLeftOperand->Compile(v, i);
  m_pRightOperand->Compile(v, i);

  // compute a^b
  // on stack => b : a

  bool entier = false;
  float exponent = 0;
  if (m_pRightOperand->IsConstant(&exponent))
    entier = (exponent == (int) exponent);

  if (entier)
    {
      v.push_back('\xdb');
      v.push_back('\x54');
      v.push_back('\x24');
      v.push_back('\xfc'); // fistl   -4(%esp)

      v.push_back('\xdd');
      v.push_back('\xc0'); // ffree   %st(0)

      v.push_back('\xd9');
      v.push_back('\xf7'); // fincstp

      v.push_back('\xd9');
      v.push_back('\xe8'); // fld1

      v.push_back('\xd9');
      v.push_back('\xc9'); // fxch

      v.push_back('\x8b');
      v.push_back('\x54');
      v.push_back('\x24');
      v.push_back('\xfc'); // movl    -4(%esp),%edx

      v.push_back('\x83');
      v.push_back('\xfa');
      v.push_back('\x00'); // cmpl    $0,%edx

      v.push_back('\x7f');
      v.push_back('\x04'); // jg      27

      v.push_back('\xf7');
      v.push_back('\xda'); // negl    %edx

      v.push_back('\xd8');
      v.push_back('\xf9'); // fdivr   %st(1),%st

      v.push_back('\xd1');
      v.push_back('\xea'); // shrl    $1,%edx

      v.push_back('\x73');
      v.push_back('\x02'); // jnc     38

      v.push_back('\xdc');
      v.push_back('\xc9'); // fmul    %st,%st(1)

      v.push_back('\x83');
      v.push_back('\xfa');
      v.push_back('\x00'); // cmpl    $0,%edx

      v.push_back('\x74');
      v.push_back('\x04'); // je      41

      v.push_back('\xd8');
      v.push_back('\xc8'); // fmul    %st(0),%st

      v.push_back('\xeb');
      v.push_back('\xf1'); // jmp     32

      v.push_back('\xdd');
      v.push_back('\xc0'); // ffree   %st(0)

      v.push_back('\xd9');
      v.push_back('\xf7'); // fincstp
    }
  else
    {
      v.push_back('\xd9');
      v.push_back('\xc9'); // fxch
      // on stack => a : b

      v.push_back('\xd9');
      v.push_back('\xf1'); // fyl2x
      // on stack => b*log2(a)

      v.push_back('\xd9');
      v.push_back('\xe8'); // fld1
      // on stack => 1 : b*log2(a)

      BEFORE_PUSH(v, i);

      v.push_back('\xd9');
      v.push_back('\xc1'); // fld     %st(1)
      // on stack => b*log2(a) : 1 : b*log2(a)

      v.push_back('\xd9');
      v.push_back('\xfc'); // frndint
      // on stack => int(b*log2(a)) : 1 : b*log2(a)

      v.push_back('\xd9');
      v.push_back('\xca'); // fxch    %st(2)
      // on stack => b*log2(a) : 1 : int(b*log2(a))

      v.push_back('\xd8');
      v.push_back('\xe2'); // fsub    %st(2),%st
      // on stack => frac(b*log2(a)) : 1 : int(b*log2(a))

      v.push_back('\xd9');
      v.push_back('\xf0'); // f2xm1
      // on stack => 2^frac(b*log2(a))-1 : 1 : int(b*log2(a))

      v.push_back('\xde');
      v.push_back('\xc1'); // faddp   %st,%st(1)
      // on stack => 2^frac(b*log2(a)) : int(b*log2(a))

      AFTER_POP(v, i);

      // 2^frac(b*log2(a))*2^int(b*log2(a))=2^(b*log2(a))=a^b

      v.push_back('\xd9');
      v.push_back('\xfd'); // fscale
      // on stack => a^b : int(b*log2(a))

      v.push_back('\xd9');
      v.push_back('\xc9'); // fxch
      // on stack => int(b*log2(a)) : a^b


      v.push_back('\xdd');
      v.push_back('\xc0'); // ffree  %st(0)

      v.push_back('\xd9');
      v.push_back('\xf7'); // fincstp
      // on stack => a^b
    }

  AFTER_POP(v, i);
}

void CVariable::Compile(std::vector<char>& v, int& i) const
{
  BEFORE_PUSH(v, i);

  v.push_back('\xd9');
  v.push_back('\x40');
  v.push_back(m_Type*4); // flds 4*m_Type(%eax)
}

void CNumber::Compile(std::vector<char>& v, int& i) const
{
  BEFORE_PUSH(v, i);

  v.push_back('\xd9');
  v.push_back('\x05');

  v.push_back((char)((int)&m_Number));
  v.push_back((char)((int)&m_Number >> 8));
  v.push_back((char)((int)&m_Number >> 16));
  v.push_back((char)((int)&m_Number >> 24)); // flds   &m_Number
}

---