Operator.h

Go to the documentation of this file.

#pragma once
#include "MathNode.h"
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <memory>
#include <unordered_set>
 
 
enum OperatorPriority {
  OPClassUnknown     = 0,
  OPClassLine        = 1,
  OPClassDot         = 2,
  OPClassPow         = 3,
  OPClassParentheses = 4,
  OPClassFunction    = 5,
};
 
enum OperatorType {
  TYPE_ADDITION          = 0, // ConnectionType_Dual
  TYPE_SUBTRACTION       = 1, // ConnectionType_Dual
  TYPE_MULTIPLICATION    = 2, // ConnectionType_Dual
  TYPE_DIVISION          = 3, // ConnectionType_Dual
  TYPE_POWER             = 4, // ConnectionType_Dual
  TYPE_PARENTHESES_OPEN  = 5, // ConnectionType_None
  TYPE_PARENTHESES_CLOSE = 6, // ConnectionType_None
};
 
enum OperatorValue : char {
  VALUE_ADDITION = '+',
  VALUE_SUBTRACTION = '-',
  VALUE_MULTIPLICATION = '*',
  // l / r
  VALUE_DIVISION = '/',
  VALUE_POWER = '^',
  VALUE_PARENTHESES_OPEN = '(',
  VALUE_PARENTHESES_CLOSE = ')',
};
 
class Operator : public MathNode
{
public:
  std::function<double(double, double)> op;
  OperatorPriority priority;
  Operator(const std::string& name, std::function<double(double, double)> fun, OperatorPriority operatorPriority)
    : MathNode(name)
    , op(std::move(fun))
    , priority(operatorPriority) {
    type = MathNodeType::NodeType_Operator;
  }
 
  Operator(const Operator& other)
    : MathNode(other) {
    op       = other.op;
    priority = other.priority;
  }
 
  [[nodiscard]] double Evaluate() const override {
    if(priority == OPClassParentheses) { return left->Evaluate(); }
    assert(left != nullptr && right != nullptr);
    return op(left->Evaluate(), right->Evaluate());
  }
};
 
std::shared_ptr<Operator> GenerateOperator(OperatorType type);
 
 
class Function : public Operator
{
public:
  Function(const std::string& val, const std::function<double(double)>& fun)
    : Operator(
    val, [fun](double a, [[maybe_unused]] double b) { return fun(a); }, OperatorPriority::OPClassFunction) {
    connectionType = NodeConnectionType::ConnectionType_Left;
    type           = MathNodeType::NodeType_Functional;
  }
 
  Function(const std::string& val, const std::function<double(double, double)>& fun)
    : Operator(val, fun, OperatorPriority::OPClassFunction) {
    connectionType = NodeConnectionType::ConnectionType_Dual;
    type           = MathNodeType::NodeType_Functional;
    std::cerr << "This can't be parsed yet!!!!!!" << std::endl;
  }
 
  [[nodiscard]] double Evaluate() const override {
    if(connectionType == NodeConnectionType::ConnectionType_Left) return op(left->Evaluate(), 0.0);
    return NAN;
  }
 
  // TODO: add beautified string representation
};
const std::map<std::string, std::shared_ptr<Function>> DefaultFunctions = {
  { "sqrt", std::make_shared<Function>("sqrt", [](double a) { return sqrt(a); }) },
  { "log", std::make_shared<Function>("log", [](double a) { return log(a); }) },
  { "sin", std::make_shared<Function>("sin", [](double a) { return sin(a); }) },
  { "cos", std::make_shared<Function>("cos", [](double a) { return cos(a); }) },
};
bool isFunction(const std::string& in);