InlineCalculator.cpp

Go to the documentation of this file.

#include "InlineCalculator.h"

// std library
#include <cmath>

// Qt library
#include <QMap>
#include <QString>
#include <QStringList>
#include <QVariant>
#include <QVector>

// boost library
#include <boost/foreach.hpp>

// naif library
#include <SpiceUsr.h>
#include <SpiceZfc.h>
#include <SpiceZmc.h>

// other ISIS
#include "IException.h"
#include "InlineInfixToPostfix.h"
#include "IString.h"
#include "NaifStatus.h"

using namespace std;

namespace Isis {

  InlineCalculator::InlineCalculator() : Calculator() {
    initialize();
  }
 

  InlineCalculator::InlineCalculator(const QString &equation) : Calculator() {
    initialize();
    compile(equation);
  }
 

  InlineCalculator::~InlineCalculator() {
    destruct();
  }
 
 
  int InlineCalculator::size() const {
    return (m_functions.size());
  }
 
 
  QString InlineCalculator::equation() const {
    return (m_equation);
  }
 
 
  bool InlineCalculator::compile(const QString &equation) {
    //  Transform equation to postfix order
 
    QString tokenOps = toPostfix(equation);
    tokenOps = tokenOps.simplified();

    int nerrors = 0;
    QString error =  "Errors parsing inline equation[" + equation + "].";
    IException errList(IException::User, error, _FILEINFO_);
 
    Clear();  // Clear the stack
    m_equation = equation;
    m_functions.clear();  // Clear function list
 
    QStringList tokenList = tokenOps.split(" ");
    while ( !tokenList.isEmpty() ) {
      QString token = tokenList.takeFirst();
      if ( !token.isEmpty() ) {
         
        // See if the function already exists.  Note that scalars and variables
        // that are already present can safely be reused.  New occuring ones are
        // created fresh!
        FxTypePtr fx = find(token);
        if ( 0 != fx ) {
          m_functions.push_back(fx);
        }
        // New scalars and variables will create new unique function objects if
        // they do not already exist (they would be found above then)
        else if ( isScalar(token)  ) {
          fx = addFunction(new ParameterFx(token, &InlineCalculator::scalar, this));
          m_functions.push_back(fx);
        }
        else if ( isVariable(token)  ) {
          // Will also get line, sample, band, etc...
          fx = addFunction(new ParameterFx(token, &InlineCalculator::variable, this));
          m_functions.push_back(fx);
        }
        else {
            //  Parameter not recognized during compile.  All unknown tokens are
            //  assumed to be variables until run time when they are searched for
            //  in the current state of the resource pool.
          try {
            if ( !orphanTokenHandler(token) ) {
              error = "Equation element (" + token + ") invalid - token not recognized.";
              errList.append(IException(IException::User, error, _FILEINFO_));
              nerrors++;
            }
          }
          // Catch all failures from orphaned tokens
          catch (IException &e) {
            errList.append(e);
            nerrors++;
          }
        }
      }
    }
 
    //  Might want to make this optional here
    if (nerrors > 0) {  
      throw errList;
    }
    return (nerrors == 0);
  }
 

  QVector<double> InlineCalculator::evaluate(CalculatorVariablePool *variablePool) {
    QVector<double> value;
    try {
      pushVariables(variablePool);
      value = evaluate();
      popVariables();
    }
    catch (IException &ie) {
      popVariables();
      throw IException(ie, IException::Programmer,
                       "Calculation with variable pool failed.",
                       _FILEINFO_);
    }
    return (value);
  }
 

  QVector<double> InlineCalculator::evaluate() {
 
    BOOST_FOREACH (FxTypePtr function,  m_functions) {
      function->execute();
    }
 
    if (StackSize() != 1) {
      QString msg = "Too many operands in the equation [" + m_equation + "].";
      throw IException(IException::Unknown, msg, _FILEINFO_);
    }
 
    return (Pop(true));
  }
 
 
  QString InlineCalculator::toPostfix(const QString &equation) const {
    InlineInfixToPostfix parser;
    return (parser.convert(equation));
  }
 
 
  bool InlineCalculator::isScalar(const QString &scalar) {
    if (scalar.isEmpty())  return (false);
    try {
      toDouble(scalar);
      return (true);
    }
    catch (IException &e) {
      return (false);
    }
  }
 

  bool InlineCalculator::isVariable(const QString &str) {
    if (str.isEmpty()) {
      return (false);
    }
    if (!isScalar(str)) {
      return (true);
    }
    return (false);
  }
 

  void InlineCalculator::scalar(const QVariant &scalar) {
    Push(toDouble(scalar.toString()));
  }
 

  void InlineCalculator::variable(const QVariant &variable) {
    CalculatorVariablePool *variablePool = variables();
    QString key = variable.toString();
    if (variablePool->exists(key)) {
      QVector<double> values = variablePool->value(key);
      Push(values);
      return;
    }
 
    // Error!
    QString error = "Could not find variable [" + key + "] in variable pool.";
    throw IException(IException::User, error, _FILEINFO_);
  }
 

  double floatModulusOperator(double a, double b) {
    return (fmod(a, b));
  }
 

  void InlineCalculator::floatModulus() {
    QVector<double> y = Pop();
    QVector<double> x = Pop();
    QVector<double> result;
    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(),
                     floatModulusOperator);
    Push(result);
    return;
  }
 

  void InlineCalculator::radians() {
    QVector<double> degree = Pop();
    QVector<double> result;
    BOOST_FOREACH(double d, degree) {
      result.push_back(d * rpd_c());
    }
    Push(result);
    return;
  }
 

  void InlineCalculator::degrees() {
    QVector<double> radians = Pop();
    QVector<double> result;
    BOOST_FOREACH(double r, radians) {
      result.push_back(r * dpr_c());
    }
    Push(result);
    return;
  }


  void InlineCalculator::logicalOr() {
    QVector<double> inputA = Pop();
    QVector<double> inputB = Pop();
    QVector<double> results;
    if ( inputA.size() != inputB.size() ) {
      QString msg = "Failed performing logical or operation, "
                    "input vectors are of differnet lengths.";
      throw IException(IException::Unknown, msg, _FILEINFO_);
    }
    for (int i = 0; i < inputA.size(); i++) {
      results.push_back( inputA[i] || inputB[i] );
    }
    Push(results);
    return;
  }


  void InlineCalculator::logicalAnd() {
    QVector<double> inputA = Pop();
    QVector<double> inputB = Pop();
    QVector<double> results;
    if ( inputA.size() != inputB.size() ) {
      QString msg = "Failed performing logical and operation, "
                    "input vectors are of differnet lengths.";
      throw IException(IException::Unknown, msg, _FILEINFO_);
    }
    for (int i = 0; i < inputA.size(); i++) {
      results.push_back( inputA[i] && inputB[i] );
    }
    Push(results);
    return;
  }
 

  void InlineCalculator::pi() {
    Push(pi_c());
    return;
  }
 

  void InlineCalculator::eConstant() {
    Push(E);
    return;
  }
 

  bool InlineCalculator::fxExists(const QString &fxname) const {
    return (m_fxPool.contains(fxname));
  }
 

  InlineCalculator::FxTypePtr InlineCalculator::addFunction(InlineCalculator::FxTypePtr function) {
    FxTypePtr func = find(function->name());
    if (!func) {
      m_fxPool.insert(function->name(), function);
    }
    else {
      QString msg = "Function operator [" + function->name() +
                    "] exists!  Cannot replace existing functions in the pool :-(";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    return (function);
  }
 

  bool InlineCalculator::orphanTokenHandler(const QString &token) {
    return (false);
  }
 
 
  void InlineCalculator::pushVariables(CalculatorVariablePool *variablePool) {
    m_variablePoolList.push_back(variablePool);
    return;
  }
 

  CalculatorVariablePool *InlineCalculator::variables() {
    if ( !m_variablePoolList.isEmpty() ) {
      return (m_variablePoolList.back());
    }
    throw IException(IException::Programmer,
                     "Request for nonexistent variable pool.",
                     _FILEINFO_);
  }
 

  void InlineCalculator::popVariables() {
    Clear();
    if ( !m_variablePoolList.isEmpty() ) {
      m_variablePoolList.pop_back();
    }
    return;
  }
 
 
  InlineCalculator::FxTypePtr InlineCalculator::find(const QString &fxname) {
    FxPoolType::iterator fx = m_fxPool.find(fxname);
    if ( m_fxPool.end() == fx ) return NULL;
    return (*fx);
  }
 
 
  void InlineCalculator::initialize() {
    //  Set up calculator function lookup list
    addFunction(new VoidFx("^", &Calculator::Exponent, this));
    addFunction(new VoidFx("/", &Calculator::Divide, this));
    addFunction(new VoidFx("*", &Calculator::Multiply, this));
    addFunction(new VoidFx("<<", &Calculator::LeftShift, this));
    addFunction(new VoidFx(">>", &Calculator::RightShift, this));
    addFunction(new VoidFx("+", &Calculator::Add, this));
    addFunction(new VoidFx("-", &Calculator::Subtract, this));
    addFunction(new VoidFx(">", &Calculator::GreaterThan, this));
    addFunction(new VoidFx("<", &Calculator::LessThan, this));
    addFunction(new VoidFx(">=", &Calculator::GreaterThanOrEqual, this));
    addFunction(new VoidFx("<=", &Calculator::LessThanOrEqual, this));
    addFunction(new VoidFx("==", &Calculator::Equal, this));
    addFunction(new VoidFx("!=", &Calculator::NotEqual, this));
 
    //  These are not part of the Calculator class because InfixToPostfix didn't
    //  add/recognize them in the tokenizer.  See InlineInfixToPostfix class which
    //  is part of this calculator.
    addFunction(new VoidFx("&", &Calculator::And, this));
    addFunction(new VoidFx("and", &Calculator::And, this));
    addFunction(new VoidFx("|", &Calculator::Or, this));
    addFunction(new VoidFx("or", &Calculator::Or, this));
    addFunction(new InlineVoidFx("%", &InlineCalculator::floatModulus, this));  
    addFunction(new VoidFx("mod", &Calculator::Modulus, this));
    addFunction(new InlineVoidFx("fmod", &InlineCalculator::floatModulus, this));
     
    addFunction(new VoidFx("--", &Calculator::Negative, this));
    addFunction(new VoidFx("neg", &Calculator::Negative, this));  
 
    addFunction(new VoidFx("min", &Calculator::MinimumPixel, this));
    addFunction(new VoidFx("max", &Calculator::MaximumPixel, this));
    addFunction(new VoidFx("abs", &Calculator::AbsoluteValue, this));
    addFunction(new VoidFx("sqrt", &Calculator::SquareRoot, this));
    addFunction(new VoidFx("log", &Calculator::Log, this));
    addFunction(new VoidFx("ln", &Calculator::Log, this));
    addFunction(new VoidFx("log10", &Calculator::Log10, this));
    addFunction(new InlineVoidFx("pi", &InlineCalculator::pi, this));
 
    addFunction(new VoidFx("sin", &Calculator::Sine, this));
    addFunction(new VoidFx("cos", &Calculator::Cosine, this));
    addFunction(new VoidFx("tan", &Calculator::Tangent, this));
    addFunction(new VoidFx("sec", &Calculator::Secant, this));
    addFunction(new VoidFx("csc", &Calculator::Cosecant, this));
    addFunction(new VoidFx("cot", &Calculator::Cotangent, this));
    addFunction(new VoidFx("asin", &Calculator::Arcsine, this));
    addFunction(new VoidFx("acos", &Calculator::Arccosine, this));
    addFunction(new VoidFx("atan", &Calculator::Arctangent, this));
    addFunction(new VoidFx("atan2", &Calculator::Arctangent2, this));
 
    addFunction(new InlineVoidFx("degs", &InlineCalculator::degrees, this));
    addFunction(new InlineVoidFx("rads", &InlineCalculator::radians, this));
    addFunction(new InlineVoidFx("e", &InlineCalculator::eConstant, this));
    addFunction(new InlineVoidFx("||", &InlineCalculator::logicalOr, this));
    addFunction(new InlineVoidFx("&&", &InlineCalculator::logicalAnd, this));
 
    // Add new functions available for inlining
  //  m_variablePoolList = defaultVariables();
 
    return;
  }
 

  void InlineCalculator::destruct() {
    BOOST_FOREACH (FxTypePtr function,  m_fxPool) {
      delete function;
    }
 
    m_fxPool.clear();
    m_functions.clear();
    return;
  }


  CalculatorVariablePool::CalculatorVariablePool() {
  }


  CalculatorVariablePool::~CalculatorVariablePool() {
  }
 

  bool CalculatorVariablePool::exists(const QString &variable) const {
    return (true);
  }
 

  QVector<double> CalculatorVariablePool::value(const QString &variable,
                                                const int &index) const {
    QString mess = "No implementation in Calculator variable pool to provide "
                   " value for variable [" + variable + "].";
    throw IException(IException::Programmer, mess, _FILEINFO_);
  }
 

  void CalculatorVariablePool::add(const QString &key, QVector<double> &values) {
    QString mess = "No implementation in Calculator variable pool to add "
                   " value for variable [" + key + "].";
    throw IException(IException::Programmer, mess, _FILEINFO_);
  }


  FxBinder::FxBinder(const QString &name) : m_name(name) {
  }


  FxBinder::~FxBinder() {
  }
 

  QString FxBinder::name() const {
    return (m_name);
  }
 

  void FxBinder::execute() {
    dispatch();
  }
 

  void FxBinder::operator()() {  
    dispatch();
  }
 

  QVariant FxBinder::args()  {
    return (QVariant(m_name));
  }
 

  InlineVoidFx::InlineVoidFx(const QString &name, calcOp function,
                InlineCalculator *calculator) : FxBinder(name),
                                                m_func(function),
                                                m_calc(calculator)  {
  }
 

  InlineVoidFx::~InlineVoidFx() {
  }
 

  void InlineVoidFx::dispatch() {  
    CALL_MEMBER_FN(*m_calc, m_func)();  
  }
   
   
  ParameterFx::ParameterFx(const QString &name, calcOp function,
              InlineCalculator *calculator) : FxBinder(name),
                                              m_func(function),
                                              m_calc(calculator){
  }
 

  ParameterFx::~ParameterFx() {
  }
 

  void ParameterFx::dispatch() {  
    CALL_MEMBER_FN(*m_calc, m_func)(args());  
  }
 
 
  VoidFx::VoidFx(const QString &name, calcOp function,
         InlineCalculator *calculator) : FxBinder(name),
                                         m_func(function),
                                         m_calc(calculator)  {
  }
 
 
  VoidFx::~VoidFx() {
  }
 
 
  void VoidFx::dispatch() {  
    CALL_MEMBER_FN(*m_calc, m_func)();  
  }
} // namespace Isis