builtins.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cmath> // IWYU pragma: keep
#include <functional>
#include <unordered_map>
#include <vector>
 
#include "tcalc/ast/function.hpp"
#include "tcalc/ast/node.hpp"
#include "tcalc/ast/program.hpp"
#include "tcalc/common.hpp"
#include "tcalc/error.hpp"
 
namespace tcalc {
 
class EvalContext;
 
}
 
namespace tcalc::builtins {
 
using Function = std::function<error::Result<double>(const std::vector<double>&,
                                                     const EvalContext&)>;
 
class TCALC_PUBLIC FunctionWrapper
{
private:
  ast::NodePtr<ast::FdefNode> _node;
 
public:
  explicit FunctionWrapper(ast::NodePtr<ast::FdefNode> node)
    : _node{ std::move(node) }
  {
  }
 
  ~FunctionWrapper() = default;
 
  error::Result<double> operator()(const std::vector<double>& args,
                                   const EvalContext& ctx) const;
};
 
class TCALC_PUBLIC ImportWrapper
{
private:
  ast::NodePtr<ast::ProgramImportNode> _node;
 
public:
  explicit ImportWrapper(ast::NodePtr<ast::ProgramImportNode> node)
    : _node{ std::move(node) }
  {
  }
 
  ~ImportWrapper() = default;
 
  error::Result<void> import(EvalContext& ctx) const;
};
 
TCALC_PUBLIC error::Result<double>
sqrt(const std::vector<double>& args, const EvalContext& ctx);
 
TCALC_PUBLIC error::Result<double>
pow(const std::vector<double>& args, const EvalContext& ctx);
 
TCALC_PUBLIC error::Result<double>
log(const std::vector<double>& args, const EvalContext& ctx);
 
TCALC_PUBLIC error::Result<double>
sin(const std::vector<double>& args, const EvalContext& ctx);
 
TCALC_PUBLIC error::Result<double>
cos(const std::vector<double>& args, const EvalContext& ctx);
 
TCALC_PUBLIC error::Result<double>
tan(const std::vector<double>& args, const EvalContext& ctx);
 
TCALC_PUBLIC error::Result<double>
acos(const std::vector<double>& args, const EvalContext& ctx);
 
TCALC_PUBLIC error::Result<double>
asin(const std::vector<double>& args, const EvalContext& ctx);
 
TCALC_PUBLIC error::Result<double>
atan(const std::vector<double>& args, const EvalContext& ctx);
 
TCALC_PUBLIC error::Result<double>
exp(const std::vector<double>& args, const EvalContext& ctx);
 
inline const std::unordered_map<std::string, double> BUILTIN_VARIABLES = {
  { "pi", M_PI },
  { "e", M_E },
}; 
inline const std::unordered_map<std::string, Function> BUILTIN_FUNCTIONS = {
  { "sqrt", sqrt }, { "pow", pow }, { "log", log },   { "sin", sin },
  { "cos", cos },   { "tan", tan }, { "acos", acos }, { "asin", asin },
  { "atan", atan }, { "exp", exp }
}; 
}