Isis 3.0 Object Programmers' Reference

Home

---

Calculator.cpp

Go to the documentation of this file.

#include <cmath>

#include "ProcessByLine.h"
#include "Calculator.h"
#include "InfixToPostfix.h"
#include "iException.h"
#include "SpecialPixel.h"

using namespace std;

namespace Isis {
  double NegateOperator(double a) { return -1*a; }


  double MultiplyOperator(double a, double b) { return a*b; }


  double DivideOperator(double a, double b) { return a/b; }


  double AddOperator(double a, double b) { return a+b; }


  double SubtractOperator(double a, double b) { return a-b; }


  double GreaterThanOperator(double a, double b) { return a > b ? 1.0 : 0.0; }


  double LessThanOperator(double a, double b) { return a < b ? 1.0 : 0.0; }


  double EqualOperator(double a, double b) { return a == b ? 1.0 : 0.0; }


  double GreaterThanOrEqualOperator(double a, double b) { return a >= b ? 1.0 : 0.0; }


  double LessThanOrEqualOperator(double a, double b) { return a <= b ? 1.0 : 0.0; }


  double NotEqualOperator(double a, double b) { return a != b ? 1.0 : 0.0; }


  double CosecantOperator(double a) { return 1.0 / sin(a); }


  double SecantOperator(double a) { return 1.0 / cos(a); }

  double CotangentOperator(double a) { return 1.0 / tan(a); }


  int Round(double a) { return (a>0)? (int)(a+0.5) : (int)(a-0.5); }


  double BitwiseAndOperator(double a, double b) { return (double)(Round(a)&Round(b)); }


  double BitwiseOrOperator(double a, double b) { return (double)(Round(a)|Round(b)); }


  double ModulusOperator(double a, double b) { return (double)(Round(a)%Round(b)); }


  Calculator::Calculator() {}


  void Calculator::Negative() {
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), NegateOperator);
    Push(result);
  }


  void Calculator::Multiply() {
    std::vector<double> y = Pop();
    std::vector<double> x = Pop();
    std::vector<double> result;

    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(), MultiplyOperator);
    Push(result); 
  }


  void Calculator::Add() { 
    std::vector<double> y = Pop(); 
    std::vector<double> x = Pop();
    std::vector<double> result;
    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(), AddOperator);
    Push(result);
  }


  void Calculator::Subtract() { 
    std::vector<double> y = Pop();
    std::vector<double> x = Pop();
    std::vector<double> result;
    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(), SubtractOperator);
    Push(result);
  }


  void Calculator::Divide() { 
    std::vector<double> y = Pop();
    std::vector<double> x = Pop();
    std::vector<double> result;

    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(), DivideOperator);
    Push(result);
  }

  void Calculator::Modulus() { 
    std::vector<double> y = Pop();
    std::vector<double> x = Pop();
    std::vector<double> result;

    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(), ModulusOperator);
    Push(result);
  }


  void Calculator::Exponent() {
    std::vector<double> exponent = Pop();
    std::vector<double> x = Pop();
    std::vector<double> result;

    PerformOperation(result, x.begin(), x.end(), exponent.begin(), exponent.end(), pow);
    Push(result);
  }


  void Calculator::SquareRoot() {
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), sqrt);
    Push(result);
  }


  void Calculator::AbsoluteValue() {
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), fabs);
    Push(result);
  }


  void Calculator::Log() {
     std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), log);
    Push(result);
  }


  void Calculator::Log10() {
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), log10);
    Push(result);
  }


  void Calculator::LeftShift() {
    std::vector<double> y = Pop();
    if(y.size() != 1) {
      std::string msg = "Must use scalars for shifting.";
      throw Isis::iException::Message(Isis::iException::Math, msg, _FILEINFO_);
    }
    else { 
      std::vector<double> x = Pop();
  
      if((int)y[0] > (int)x.size()) { 
        std::string msg = "Shift value must be <= to number of samples.";
        throw Isis::iException::Message(Isis::iException::Math, msg, _FILEINFO_);
      }
      else {
        std::vector<double> result;
        int shift = (int)y[0];
        result.resize(x.size());

        for(unsigned int i = 0; i < result.size(); i++) {
          if(i+shift < x.size() && i+shift >= 0)
            result[i] = x[i+shift];
          else
            result[i] = sqrt(-1.0); // create a NaN
        }

        Push(result);
      }
    }
  }


  void Calculator::RightShift() {
    std::vector<double> y = Pop();
    if(y.size() != 1) {
      std::string msg = "Must use scalars for shifting.";
      throw Isis::iException::Message(Isis::iException::Math, msg, _FILEINFO_);
    }
    else { 
      std::vector<double> x = Pop();
  
      if((int)y[0] > (int)x.size()) { 
        std::string msg = "Shift value must be <= to number of samples.";
        throw Isis::iException::Message(Isis::iException::Math, msg, _FILEINFO_);
      }
      else {
        std::vector<double> result;
        int shift = (int)y[0];
        result.resize(x.size());

        for(int i = 0; i < (int)result.size(); i++) {
          if(i-shift < (int)x.size() && i-shift >= 0) {
            result[i] = x[i-shift];
          }
          else {
            result[i] = sqrt(-1.0); // create a NaN
          }
        }

        Push(result);
      }
    }
  }


  void Calculator::Minimum() {
    std::vector<double> result = Pop();

    int size = result.size();
    double minVal = result[0];
    for(unsigned int i = 0; i < result.size(); i++) minVal = min(minVal, result[i]);

    result.clear();
    result.resize(size, minVal);
    Push(result);
  }


  void Calculator::Maximum() {
    std::vector<double> result = Pop();

    int size = result.size();
    double maxVal = result[0];
    for(unsigned int i = 0; i < result.size(); i++) maxVal = max(maxVal, result[i]);

    result.clear();
    result.resize(size, maxVal);
    Push(result);
  }


  void Calculator::GreaterThan() {
    std::vector<double> y = Pop();
    std::vector<double> x = Pop();
    std::vector<double> result;

    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(), GreaterThanOperator);
    Push(result);
  }


  void Calculator::LessThan() {
    std::vector<double> y = Pop();
    std::vector<double> x = Pop();
    std::vector<double> result;

    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(), LessThanOperator);
    Push(result);
  }


  void Calculator::Equal() {
    std::vector<double> y = Pop();
    std::vector<double> x = Pop();
    std::vector<double> result;

    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(), EqualOperator);
    Push(result);
  }


  void Calculator::GreaterThanOrEqual() {
    std::vector<double> y = Pop();
    std::vector<double> x = Pop();
    std::vector<double> result;

    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(), GreaterThanOrEqualOperator);
    Push(result);
  }


  void Calculator::LessThanOrEqual() {
    std::vector<double> y = Pop();
    std::vector<double> x = Pop();
    std::vector<double> result;

    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(), LessThanOrEqualOperator);
    Push(result);
  }


  void Calculator::NotEqual() {
    std::vector<double> y = Pop();
    std::vector<double> x = Pop();
    std::vector<double> result;

    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(), NotEqualOperator);
    Push(result);
  }


  // Commented out because bitwise ops only work with integers instead of doubles

  void Calculator::And() {
    std::vector<double> y = Pop();
    std::vector<double> x = Pop();
    std::vector<double> result;

    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(), BitwiseAndOperator);
    Push(result);
  }


  void Calculator::Or() {
    std::vector<double> y = Pop();
    std::vector<double> x = Pop();
    std::vector<double> result;

    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(), BitwiseOrOperator);
    Push(result);
  }


  void Calculator::Sine() { 
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), sin);
    Push(result);
  }


  void Calculator::Cosine() { 
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), cos);
    Push(result);
  }


  void Calculator::Tangent() { 
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), tan);
    Push(result);
  }


  void Calculator::Cosecant() { 
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), CosecantOperator);
    Push(result);
  }


  void Calculator::Secant() { 
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), SecantOperator);
    Push(result);
  }


  void Calculator::Cotangent() { 
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), CotangentOperator);
    Push(result);
  }


  void Calculator::Arcsine() { 
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), asin);
    Push(result);
  }


  void Calculator::Arccosine() { 
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), acos);
    Push(result);
  }


  void Calculator::Arctangent() { 
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), atan);
    Push(result);
  }


  void Calculator::ArcsineH() {
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), asinh);
    Push(result);
  }


  void Calculator::ArccosineH() {
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), acosh);
    Push(result);
  }


  void Calculator::ArctangentH() {
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), atanh);
    Push(result);
  }


  void Calculator::Arctangent2() {
    std::vector<double> y = Pop();
    std::vector<double> x = Pop();
    std::vector<double> result;

    PerformOperation(result, x.begin(), x.end(), y.begin(), y.end(), atan2);
    p_valStack.push(result);
  }


  void Calculator::SineH() { 
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), sinh);
    Push(result);
  }


  void Calculator::CosineH() { 
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), cosh);
    Push(result);
  }


  void Calculator::TangentH() { 
    std::vector<double> result = Pop();
    PerformOperation(result, result.begin(), result.end(), tanh);
    Push(result);
  }


  // Stack methods

  void Calculator::Push(std::vector<double> &vect) {
    p_valStack.push(vect);
  }


  void Calculator::Push(double scalar) {
    std::vector<double> s;
    s.push_back(scalar);
    Push(s);
  }


  void Calculator::Push(Buffer &buff) {
    std::vector<double> b(buff.size());
  
    for(int i = 0; i < buff.size(); i++) {
      // Test for special pixels and map them to valid values
      if(IsSpecial(buff[i])) { 
        if(Isis::IsNullPixel(buff[i])) {
          //b[i] = NAN;
          b[i] = sqrt(-1.0);
        }
        else if(Isis::IsHrsPixel(buff[i])) {
          //b[i] = INFINITY;
          b[i] = DBL_MAX * 2;
        }
        else if(Isis::IsHisPixel(buff[i])) {
          //b[i] = INFINITY;
          b[i] = DBL_MAX * 2;
        }
        else if(Isis::IsLrsPixel(buff[i])) {
          //b[i] = -INFINITY;
          b[i] = -DBL_MAX * 2;
        }
        else if(Isis::IsLisPixel(buff[i])) {
          //b[i] = -INFINITY;
          b[i] = -DBL_MAX * 2;
        }
      }
      else    
        b[i] = buff[i];
    } 
    p_valStack.push(b);
  }


  std::vector<double> Calculator::Pop(bool keepSpecials) {
    std::vector<double> top;

    if(p_valStack.empty()) {
      std::string msg = "Stack is empty, cannot perform any more operations.";
      throw Isis::iException::Message(Isis::iException::Math, msg, _FILEINFO_);
    }

    top = p_valStack.top();

    if(keepSpecials) {
      for(int i = 0; i < (int)top.size(); i++) {
        if(isnan(top[i])) {
          top[i] = Isis::Null;
        }
        // Test for +INFINITY
        else if(top[i] > DBL_MAX) {
          top[i] = Isis::Hrs;
        }
        // Test for -INFINITY)
        else if(top[i] < -DBL_MAX) {
          top[i] = Isis::Lrs;
        }
        else { 
          // Do nothing 
        }
      }
    }
    
    p_valStack.pop();


    return top;
  }


  void Calculator::PrintTop() {
    if(p_valStack.empty()) return;
    
    std::cout << "[ ";
    std::vector<double> top = p_valStack.top();
    for(int i = 0; i < (int)top.size(); i++) {
      std::cout << top[i] << " ";
    }
    std::cout << "]" << std::endl;
  }


  bool Calculator::Empty() {
    return p_valStack.empty();
  }


  void Calculator::Clear() {
    while(!p_valStack.empty()) {
      p_valStack.pop();
    }
  }


  void Calculator::PerformOperation(std::vector<double> &results,
                                    std::vector<double>::iterator arg1Start, 
                                    std::vector<double>::iterator arg1End,
                                    double operation(double))
  {
    results.resize(arg1End-arg1Start);

    for(unsigned int pos = 0; pos < results.size(); pos++) {
      results[pos] = operation(*arg1Start);
      arg1Start++;
    }
  }


  void Calculator::PerformOperation(std::vector<double> &results,
                                    std::vector<double>::iterator arg1Start, 
                                    std::vector<double>::iterator arg1End,
                                    std::vector<double>::iterator arg2Start,
                                    std::vector<double>::iterator arg2End,
                                    double operation(double, double)) {
    if(arg1End-arg1Start != 1 && arg2End-arg2Start != 1 && 
       arg1End-arg1Start != arg2End-arg2Start) {
      std::string msg = "Cannot operate on vectors of differing sizes.";
      throw Isis::iException::Message(Isis::iException::Math, msg, _FILEINFO_);
    }

    int iSize = max(arg1End-arg1Start, arg2End-arg2Start);
    results.resize(iSize);

    for(unsigned int pos = 0; pos < results.size(); pos++) {
      results[pos] = operation(*arg1Start, *arg2Start);

      if(arg1Start+1 != arg1End) arg1Start++;
      if(arg2Start+1 != arg2End) arg2Start++;
    }
  }
} // End of namespace Isis