CMathExpression.h

Go to the documentation of this file.

#ifndef CMATHEXPRESSION_H
#define CMATHEXPRESSION_H


class CMathExpression
{
 public:
  CMathExpression(const char * Equation = 0);

  CMathExpression(const CMathExpression& copy)
    { m_pFormula = copy.m_pFormula->GetCopy(); }

  const CMathExpression& operator=(const CMathExpression& copy)
    {
      if (this != &copy)
        {
          if (m_pFormula)
            delete m_pFormula;

          m_pFormula = copy.m_pFormula->GetCopy();
        }
      return *this;
    }

  float GetValue(const CVector3f& Point) const 
    {
      // To be able to switch between run-time generated code
      // and tree-based evaluation
#if 0
      POP_ASSERT(m_pFormula != NULL, "Using a NULL pointer.");
      return (m_pFormula->Compute(Point));
#else
      POP_ASSERT(m_pFunction != NULL, "Using a NULL pointer.");
      return ((*m_pFunction)(Point));
#endif
    }

  CMathExpression* GetDerivative(CValue::TYPE_VARIABLE Type) const
    { 
      POP_ASSERT(m_pFormula != NULL, "Using a NULL pointer.");
      CMathExpression* ptrDerivative = new CMathExpression;
      ptrDerivative->m_pFormula = m_pFormula->Derive(Type);
      ptrDerivative->Compile();
      return ptrDerivative;
    }

  void Print(std::ostream& o) const
    {
      POP_ASSERT(m_pFormula != NULL, "Using a NULL pointer.");
      m_pFormula->Print(o);
    }

  std::string GetString() const
    {
      POP_ASSERT(m_pFormula != NULL, "Using a NULL pointer.");
      std::ostringstream o;
      m_pFormula->Print(o);
      return o.str();
    }

  ~CMathExpression()
    {
      if (m_pFormula)
        delete m_pFormula;
      if (m_pFunction)
        delete [] (char *) m_pFunction;
    }

  static bool Validate(const std::string& Formula, int *value = NULL,
                       int min = -1, int max = -1);

 private:
  CValue* m_pFormula; 
  float (*m_pFunction)(const CVector3f&); 
  static CValue* BuildFormula(const char* Formula, int min, int max);

  void Compile(std::vector<char>& v) const;

  void Compile()
    {
      if (m_pFunction)
        delete [] (char *) m_pFunction;

      // Compilation of the calculation function
      std::vector<char> buffer;
      Compile(buffer);
      char * pFunc = new char[buffer.size()];
      memcpy(pFunc, &buffer[0], buffer.size()*sizeof(char));
      m_pFunction = (float (*)(const CVector3f&)) pFunc;
    }
};

#endif  // CMATHEXPRESSION_H

---