Operand.h

Go to the documentation of this file.

#pragma once
 
 
#include "MathNode.h"
#include <cmath>
#include <cstdlib>
#include <map>
#include <memory>
#include <string>
#include <unordered_set>
class Operand : public MathNode
{
public:
  explicit Operand(const std::string& name)
    : MathNode(name) {
    connectionType = NodeConnectionType::ConnectionType_None;
  }
};
 
class Symbolic : public Operand
{
public:
  double evaluationValue = 1.0;
 
  explicit Symbolic(const std::string& name, double defaultValue = 0.0)
    : Operand(name)
    , evaluationValue(defaultValue) {
    type = MathNodeType::NodeType_Symbolic;
  }
 
  Symbolic(const Symbolic& other)
    : Operand(other) {
    type            = other.type;
    evaluationValue = other.evaluationValue;
  }
 
  [[nodiscard]] double Evaluate() const override { return isNegative ? evaluationValue * (-1.0) : evaluationValue; }
};
 
static std::map<std::string, std::shared_ptr<Symbolic>> DefaultSymbols = {
  { "pi", std::make_shared<Symbolic>("pi", 3.1415926535897932384626433832795028841971693993751058209749445923078164) },
  { "e", std::make_shared<Symbolic>("e", 2.71828182845904523536028747135266249775724709369995957496696762772407663) },
};
 
bool isConstant(const std::string& in);
bool hasSymbol(const std::vector<std::shared_ptr<Symbolic>>& container, const std::shared_ptr<Symbolic>& sym);
 
class Number : public Operand
{
  double numericValue;
 
public:
  explicit Number(const std::string& val)
    : Operand(val) {
    type                  = MathNodeType::NodeType_Numeric;
    numericValue          = strtod(value, nullptr);
    isNegative            = (numericValue > 0) ? false : ((numericValue < 0) ? true : false);
    numericValue          = fabs(numericValue);
    std::string realValue = std::to_string(numericValue);
    value                 = new char[realValue.size() + 1];
    std::copy(realValue.begin(), realValue.end(), value);
    value[realValue.size()] = '\0'; // don't forget the terminating 0
  }
 
  [[nodiscard]] double Evaluate() const override { return isNegative ? numericValue * (-1.0) : numericValue; }
};