@lakutata/math 0.0.0-stage → 3.1.3

package/native/config/symengine/symengine_config.h

@@ -0,0 +1,44 @@
+/*
+ * The configuration of SymEngine in @lakutata/math, in place of the one CMake writes from symengine_config.h.in: the
+ * integers and rationals of Boost.Multiprecision (no GMP), atomic reference counts (the addon uses SymEngine from its
+ * threads), RTTI. Kept in step with vendor/symengine/symengine (scripts/sync.mjs).
+ */
+#ifndef SYMENGINE_CONFIG_HPP
+#define SYMENGINE_CONFIG_HPP
+
+#define SYMENGINE_MAJOR_VERSION 0
+#define SYMENGINE_MINOR_VERSION 15
+#define SYMENGINE_PATCH_VERSION 0
+#define SYMENGINE_VERSION "0.15.0"
+
+#define WITH_SYMENGINE_RCP
+#define WITH_SYMENGINE_THREAD_SAFE
+#define HAVE_SYMENGINE_BOOST
+
+#define HAVE_DEFAULT_CONSTRUCTORS
+#define HAVE_SYMENGINE_NOEXCEPT
+#define HAVE_SYMENGINE_IS_CONSTRUCTIBLE
+#define HAVE_SYMENGINE_RESERVE
+#define HAVE_SYMENGINE_STD_TO_STRING
+#define HAVE_SYMENGINE_RTTI 1
+
+#define SYMENGINE_GMPXX 0
+#define SYMENGINE_PIRANHA 1
+#define SYMENGINE_FLINT 2
+#define SYMENGINE_GMP 3
+#define SYMENGINE_BOOSTMP 4
+
+#define SYMENGINE_INTEGER_CLASS SYMENGINE_BOOSTMP
+
+/* Not used by SymEngine outside of this file */
+#define SYMENGINE_SIZEOF_LONG_DOUBLE 16
+
+#ifdef HAVE_SYMENGINE_NOEXCEPT
+#  define SYMENGINE_NOEXCEPT noexcept
+#else
+#  define SYMENGINE_NOEXCEPT
+#endif
+
+#include <symengine/symengine_export.h>
+
+#endif

package/native/config/symengine/symengine_export.h

@@ -0,0 +1,19 @@
+/*
+ * The export macros of SymEngine in @lakutata/math, in place of the ones CMake's GenerateExportHeader writes: SymEngine
+ * is compiled into the addon, nothing is exported from it.
+ */
+#ifndef SYMENGINE_EXPORT_H
+#define SYMENGINE_EXPORT_H
+
+#define SYMENGINE_EXPORT
+#define SYMENGINE_NO_EXPORT
+
+#ifdef _MSC_VER
+#  define SYMENGINE_DEPRECATED __declspec(deprecated)
+#else
+#  define SYMENGINE_DEPRECATED __attribute__((__deprecated__))
+#endif
+#define SYMENGINE_DEPRECATED_EXPORT SYMENGINE_EXPORT SYMENGINE_DEPRECATED
+#define SYMENGINE_DEPRECATED_NO_EXPORT SYMENGINE_NO_EXPORT SYMENGINE_DEPRECATED
+
+#endif

package/native/core/Errors.cpp

@@ -0,0 +1,77 @@
+#include "Errors.h"
+
+#include <new>
+#include <symengine/symengine_exception.h>
+
+namespace math {
+
+const char *codeName(ErrorCode code)
+{
+    switch (code) {
+        case ErrorCode::Syntax: return "E_MATH_SYNTAX";
+        case ErrorCode::UnknownFunction: return "E_MATH_UNKNOWN_FUNCTION";
+        case ErrorCode::Definition: return "E_MATH_DEFINITION";
+        case ErrorCode::Domain: return "E_MATH_DOMAIN";
+        case ErrorCode::DivisionByZero: return "E_MATH_DIVISION_BY_ZERO";
+        case ErrorCode::NotSupported: return "E_MATH_NOT_SUPPORTED";
+        case ErrorCode::Unit: return "E_MATH_UNIT";
+        case ErrorCode::Cancelled: return "E_MATH_CANCELLED";
+        case ErrorCode::Timeout: return "E_MATH_TIMEOUT";
+        case ErrorCode::Argument: return "E_MATH_ARGUMENT";
+        case ErrorCode::Internal: return "E_MATH_INTERNAL";
+    }
+    return "E_MATH_INTERNAL";
+}
+
+MathError::MathError(ErrorCode code, const std::string &message, long position)
+    : std::runtime_error(message), code_(code), position_(position)
+{
+}
+
+ErrorCode MathError::code() const
+{
+    return code_;
+}
+
+long MathError::position() const
+{
+    return position_;
+}
+
+ErrorInfo currentErrorInfo()
+{
+    try {
+        throw;
+    } catch (const MathError &error) {
+        return {error.code(), error.what(), error.position()};
+    } catch (SymEngine::SymEngineException &error) {
+        switch (error.error_code()) {
+            case SYMENGINE_DIV_BY_ZERO: return {ErrorCode::DivisionByZero, error.what(), -1};
+            case SYMENGINE_NOT_IMPLEMENTED: return {ErrorCode::NotSupported, error.what(), -1};
+            case SYMENGINE_DOMAIN_ERROR: return {ErrorCode::Domain, error.what(), -1};
+            case SYMENGINE_PARSE_ERROR: return {ErrorCode::Syntax, error.what(), -1};
+            default: return {ErrorCode::Internal, error.what(), -1};
+        }
+    } catch (const std::bad_alloc &) {
+        return {ErrorCode::Internal, "Out of memory", -1};
+    } catch (const std::exception &error) {
+        return {ErrorCode::Internal, error.what(), -1};
+    } catch (...) {
+        return {ErrorCode::Internal, "Unknown error", -1};
+    }
+}
+
+Napi::Error toError(Napi::Env env, const ErrorInfo &info)
+{
+    Napi::Error error = Napi::Error::New(env, info.message);
+    error.Set("code", codeName(info.code));
+    if (info.position >= 0) error.Set("position", Napi::Number::New(env, static_cast<double>(info.position)));
+    return error;
+}
+
+Napi::Error currentError(Napi::Env env)
+{
+    return toError(env, currentErrorInfo());
+}
+
+}

package/native/core/Errors.h

@@ -0,0 +1,72 @@
+//The errors of the addon: a code and a message, thrown in JavaScript as an Error with a `code` (and a `position` for
+//the errors of syntax), which src/lib/Native.ts turns into the exceptions of the package
+#pragma once
+
+#include <napi.h>
+#include <stdexcept>
+#include <string>
+
+namespace math {
+
+enum class ErrorCode {
+    Syntax,
+    UnknownFunction,
+    Definition,
+    Domain,
+    DivisionByZero,
+    NotSupported,
+    Unit,
+    Cancelled,
+    Timeout,
+    Argument,
+    Internal
+};
+
+//The name of a code in JavaScript: E_MATH_SYNTAX…
+const char *codeName(ErrorCode code);
+
+class MathError : public std::runtime_error {
+public:
+    //An error; the position of a syntax error is the index of the character in the text (UTF-16, as JavaScript counts)
+    MathError(ErrorCode code, const std::string &message, long position = -1);
+
+    ErrorCode code() const;
+
+    long position() const;
+
+private:
+    ErrorCode code_;
+    long position_;
+};
+
+//The JavaScript error of the exception being handled (in a catch): the errors of the addon, of SymEngine, of the
+//standard library
+Napi::Error currentError(Napi::Env env);
+
+//The code and the message of the exception being handled, for the threads that cannot make JavaScript values
+struct ErrorInfo {
+    ErrorCode code;
+    std::string message;
+    long position;
+};
+
+ErrorInfo currentErrorInfo();
+
+//The JavaScript error of an ErrorInfo
+Napi::Error toError(Napi::Env env, const ErrorInfo &info);
+
+//A function of the addon: its C++ exceptions thrown in JavaScript as errors with a code (an exception crossing
+//Node-API would end the process)
+template <Napi::Value (*F)(const Napi::CallbackInfo &)>
+Napi::Value guarded(const Napi::CallbackInfo &info)
+{
+    try {
+        return F(info);
+    } catch (const Napi::Error &) {
+        throw;
+    } catch (...) {
+        throw currentError(info.Env());
+    }
+}
+
+}

package/native/core/Handle.cpp

@@ -0,0 +1,109 @@
+#include "Handle.h"
+
+#include <algorithm>
+#include <unordered_map>
+
+#include <symengine/add.h>
+#include <symengine/constants.h>
+#include <symengine/mul.h>
+#include <symengine/pow.h>
+
+#include "Errors.h"
+
+namespace math {
+
+//Random 128-bit tags, one by type of handle
+const napi_type_tag EXPRESSION_TAG = {0x6c616b7574617461ULL, 0x6d61746845787072ULL};
+const napi_type_tag SCOPE_TAG = {0x6c616b7574617461ULL, 0x6d61746853636f70ULL};
+const napi_type_tag COMPILED_TAG = {0x6c616b7574617461ULL, 0x6d617468436f6d70ULL};
+const napi_type_tag TOKEN_TAG = {0x6c616b7574617461ULL, 0x6d617468546f6b6eULL};
+const napi_type_tag MATRIX_TAG = {0x6c616b7574617461ULL, 0x6d6174684d617472ULL};
+
+void childrenOf(const SymEngine::Basic &node, std::vector<const SymEngine::Basic *> &children)
+{
+    children.clear();
+    if (SymEngine::is_a_Number(node) || SymEngine::is_a<SymEngine::Symbol>(node) || SymEngine::is_a<SymEngine::Constant>(node)) return;
+    if (SymEngine::is_a<SymEngine::Add>(node)) {
+        for (const auto &[term, coefficient] : SymEngine::down_cast<const SymEngine::Add &>(node).get_dict()) children.push_back(term.get());
+    } else if (SymEngine::is_a<SymEngine::Mul>(node)) {
+        for (const auto &[base, exponent] : SymEngine::down_cast<const SymEngine::Mul &>(node).get_dict()) {
+            children.push_back(base.get());
+            if (!SymEngine::is_a_Number(*exponent)) children.push_back(exponent.get());
+        }
+    } else if (SymEngine::is_a<SymEngine::Pow>(node)) {
+        children.push_back(SymEngine::down_cast<const SymEngine::Pow &>(node).get_base().get());
+        children.push_back(SymEngine::down_cast<const SymEngine::Pow &>(node).get_exp().get());
+    } else {
+        for (const Expr &argument : node.get_args()) children.push_back(argument.get());
+    }
+}
+
+size_t expressionMemory(const Expr &expression)
+{
+    //The node and its children: a cheap estimate, deep enough for the sums and the products of many terms
+    std::vector<const SymEngine::Basic *> children, grandchildren;
+    childrenOf(*expression, children);
+    size_t memory = 96;
+    for (const SymEngine::Basic *child : children) {
+        childrenOf(*child, grandchildren);
+        memory += 96 + 32 * grandchildren.size();
+    }
+    return memory;
+}
+
+void checkDepth(const Expr &expression)
+{
+    //Without recursion, the height of each subexpression with children computed once (the expression is a graph)
+    struct Frame {
+        const SymEngine::Basic *node;
+        std::vector<const SymEngine::Basic *> children;
+        size_t next;
+        unsigned height;
+    };
+    std::unordered_map<const SymEngine::Basic *, unsigned> heights;
+    std::vector<Frame> path;
+    const auto deeper = [&path](unsigned below) {
+        if (path.size() + below > MAX_DEPTH) throw MathError(ErrorCode::NotSupported, "The expression is nested more than " + std::to_string(MAX_DEPTH) + " levels deep");
+    };
+    std::vector<const SymEngine::Basic *> children;
+    childrenOf(*expression, children);
+    if (children.empty()) return;
+    path.push_back({expression.get(), children, 0, 0});
+    while (!path.empty()) {
+        Frame &frame = path.back();
+        if (frame.next == frame.children.size()) {
+            const unsigned height = frame.height;
+            heights.emplace(frame.node, height);
+            path.pop_back();
+            if (!path.empty()) path.back().height = std::max(path.back().height, height + 1);
+            continue;
+        }
+        const SymEngine::Basic *child = frame.children[frame.next++];
+        const auto known = heights.find(child);
+        if (known != heights.end()) {
+            deeper(known->second + 1);
+            frame.height = std::max(frame.height, known->second + 1);
+            continue;
+        }
+        childrenOf(*child, children);
+        if (children.empty()) {
+            frame.height = std::max(frame.height, 1u);
+            continue;
+        }
+        deeper(1);
+        path.push_back({child, children, 0, 0});
+    }
+}
+
+Napi::Value wrapExpression(Napi::Env env, const Expr &expression)
+{
+    checkDepth(expression);
+    return wrap(env, std::make_shared<Expr>(expression), EXPRESSION_TAG, static_cast<int64_t>(expressionMemory(expression)));
+}
+
+Expr unwrapExpression(const Napi::Value &value)
+{
+    return *unwrap<Expr>(value, EXPRESSION_TAG, "an expression");
+}
+
+}

package/native/core/Handle.h

@@ -0,0 +1,72 @@
+//The handles of the addon: the native objects JavaScript holds (an expression, a scope of definitions, a compiled
+//function), each an External tagged with its type, released when JavaScript collects it, its memory told to V8
+#pragma once
+
+#include <napi.h>
+#include <memory>
+#include <symengine/basic.h>
+
+#include "Errors.h"
+
+namespace math {
+
+using Expr = SymEngine::RCP<const SymEngine::Basic>;
+
+//The type tags of the handles: a handle of one type given where another is expected is an error, not a crash
+extern const napi_type_tag EXPRESSION_TAG;
+extern const napi_type_tag SCOPE_TAG;
+extern const napi_type_tag COMPILED_TAG;
+extern const napi_type_tag TOKEN_TAG;
+extern const napi_type_tag MATRIX_TAG;
+
+//The subexpressions of a node, without building new ones: the terms of a sum, the bases and the exponents of a product
+//(get_args() makes a product of each term of a sum, a power of each factor of a product)
+void childrenOf(const SymEngine::Basic &node, std::vector<const SymEngine::Basic *> &children);
+
+//The approximate native memory of an expression: told to V8 so that it collects the handles of large ones in time
+size_t expressionMemory(const Expr &expression);
+
+//The deepest expressions: the operations recurse through them, in the threads of JavaScript too (4 MiB of stack in a
+//worker thread)
+constexpr unsigned MAX_DEPTH = 1000;
+
+//Throws MathError (NotSupported) for an expression deeper than MAX_DEPTH (the definitions composed in each other can
+//build one, sharing its subexpressions)
+void checkDepth(const Expr &expression);
+
+//A handle of a native object, owned by a shared_ptr (the threads of the addon may hold it too)
+template <typename T>
+struct Handle {
+    std::shared_ptr<T> value;
+    int64_t memory;
+};
+
+template <typename T>
+Napi::Value wrap(Napi::Env env, std::shared_ptr<T> value, const napi_type_tag &tag, int64_t memory)
+{
+    auto *handle = new Handle<T>{std::move(value), memory};
+    Napi::External<Handle<T>> external = Napi::External<Handle<T>>::New(env, handle, [](Napi::Env env, Handle<T> *finalized) {
+        Napi::MemoryManagement::AdjustExternalMemory(env, -finalized->memory);
+        delete finalized;
+    });
+    external.TypeTag(&tag);
+    Napi::MemoryManagement::AdjustExternalMemory(env, memory);
+    return external;
+}
+
+template <typename T>
+std::shared_ptr<T> unwrap(const Napi::Value &value, const napi_type_tag &tag, const char *what)
+{
+    if (!value.IsExternal() || !value.As<Napi::External<Handle<T>>>().CheckTypeTag(&tag)) {
+        throw MathError(ErrorCode::Argument, std::string("Not ") + what);
+    }
+    return value.As<Napi::External<Handle<T>>>().Data()->value;
+}
+
+//An expression given to JavaScript
+Napi::Value wrapExpression(Napi::Env env, const Expr &expression);
+
+//The expression of a handle
+Expr unwrapExpression(const Napi::Value &value);
+
+}

package/native/core/Scope.cpp

@@ -0,0 +1,122 @@
+#include "Scope.h"
+
+#include <set>
+#include <symengine/symbol.h>
+
+namespace math {
+
+namespace {
+
+//A signature: f(x, y) is the function f of the parameters x and y, g the constant g
+struct Signature {
+    std::string name;
+    std::vector<std::string> parameters;
+    bool function;
+};
+
+std::string trim(const std::string &text)
+{
+    const size_t first = text.find_first_not_of(" \t\r\n");
+    if (first == std::string::npos) return "";
+    return text.substr(first, text.find_last_not_of(" \t\r\n") - first + 1);
+}
+
+Signature signatureOf(const std::string &text)
+{
+    const std::string signature = trim(text);
+    const size_t open = signature.find('(');
+    Signature parsed{trim(signature.substr(0, open)), {}, open != std::string::npos};
+    if (!isName(parsed.name)) throw MathError(ErrorCode::Definition, "The definition " + signature + ": " + parsed.name + " is not a name");
+    if (isBuiltin(parsed.name)) throw MathError(ErrorCode::Definition, "The definition " + signature + ": " + parsed.name + " is a function or a constant of the formulas");
+    if (!parsed.function) return parsed;
+    if (signature.back() != ')') throw MathError(ErrorCode::Definition, "The definition " + signature + ": ) expected at its end");
+    std::string list = signature.substr(open + 1, signature.size() - open - 2);
+    std::set<std::string> seen;
+    size_t start = 0;
+    while (true) {
+        const size_t comma = list.find(',', start);
+        const std::string parameter = trim(list.substr(start, comma == std::string::npos ? std::string::npos : comma - start));
+        if (!isName(parameter) || isReserved(parameter)) throw MathError(ErrorCode::Definition, "The definition " + signature + ": " + (parameter.empty() ? "a parameter is missing" : parameter + " cannot be a parameter"));
+        if (!seen.insert(parameter).second) throw MathError(ErrorCode::Definition, "The definition " + signature + ": the parameter " + parameter + " is given twice");
+        parsed.parameters.push_back(parameter);
+        if (comma == std::string::npos) break;
+        start = comma + 1;
+    }
+    return parsed;
+}
+
+}
+
+std::shared_ptr<const Scope> Scope::make(std::shared_ptr<const Scope> parent, const std::vector<std::pair<std::string, std::string>> &definitions)
+{
+    auto scope = std::make_shared<Scope>();
+    scope->parent_ = std::move(parent);
+    scope->signatures_ = definitions;
+    std::map<std::string, std::pair<Signature, std::string>> pending;
+    for (const auto &[signature, body] : definitions) {
+        Signature parsed = signatureOf(signature);
+        const std::string name = parsed.name;
+        if (pending.count(name)) throw MathError(ErrorCode::Definition, name + " is defined twice");
+        pending.emplace(name, std::make_pair(std::move(parsed), body));
+    }
+    //Compiled when first needed, so that a definition can use another one written after it; the ones being compiled
+    //tell a cycle
+    std::vector<std::string> compiling;
+    std::function<const Definition *(const std::string &)> compile = [&](const std::string &name) -> const Definition * {
+        const auto done = scope->definitions_.find(name);
+        if (done != scope->definitions_.end()) return &done->second;
+        const auto waiting = pending.find(name);
+        if (waiting == pending.end()) return scope->parent_ ? scope->parent_->find(name) : nullptr;
+        for (const std::string &active : compiling) {
+            if (active != name) continue;
+            std::string cycle;
+            for (const std::string &step : compiling) cycle += step + " → ";
+            throw MathError(ErrorCode::Definition, "The definitions refer to each other in a cycle: " + cycle + name);
+        }
+        compiling.push_back(name);
+        const Signature &signature = waiting->second.first;
+        Definition definition;
+        definition.function = signature.function;
+        std::map<std::string, Definition> parameters;
+        for (const std::string &parameter : signature.parameters) {
+            Expr symbol = SymEngine::symbol(parameter);
+            definition.parameters.push_back(symbol);
+            parameters[parameter] = Definition{{}, symbol, false};
+        }
+        //In the body, the parameters hide the definitions of the same names
+        Resolver resolver = [&](const std::string &used) -> const Definition * {
+            const auto parameter = parameters.find(used);
+            return parameter != parameters.end() ? &parameter->second : compile(used);
+        };
+        try {
+            definition.body = parseExpression(waiting->second.second, resolver);
+        } catch (const MathError &error) {
+            if (error.code() == ErrorCode::Definition) throw;
+            throw MathError(error.code() == ErrorCode::UnknownFunction ? ErrorCode::UnknownFunction : ErrorCode::Definition,
+                "The definition of " + name + ": " + error.what(), error.position());
+        }
+        compiling.pop_back();
+        return &scope->definitions_.emplace(name, std::move(definition)).first->second;
+    };
+    for (const auto &[name, entry] : pending) compile(name);
+    return scope;
+}
+
+const Definition *Scope::find(const std::string &name) const
+{
+    const auto found = definitions_.find(name);
+    if (found != definitions_.end()) return &found->second;
+    return parent_ ? parent_->find(name) : nullptr;
+}
+
+Resolver Scope::resolver() const
+{
+    return [this](const std::string &name) { return find(name); };
+}
+
+const std::vector<std::pair<std::string, std::string>> &Scope::signatures() const
+{
+    return signatures_;
+}
+
+}

package/native/core/Scope.h

@@ -0,0 +1,36 @@
+//A scope of definitions: the functions and constants defined by formulas (f(x) = x^2 + 1, g = 9.80665), compiled once
+//when the scope is made, never changed after (a scope shared by several users cannot be changed by one of them). A
+//scope made with() another one adds definitions over its, which can replace them.
+#pragma once
+
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "../parser/Parser.h"
+
+namespace math {
+
+class Scope {
+public:
+    //Make a scope: its definitions as signatures (f(x, y), g) and bodies, over a parent scope or none
+    static std::shared_ptr<const Scope> make(std::shared_ptr<const Scope> parent, const std::vector<std::pair<std::string, std::string>> &definitions);
+
+    //The definition of a name, in this scope or its parents
+    const Definition *find(const std::string &name) const;
+
+    //A resolver of the parser over this scope
+    Resolver resolver() const;
+
+    //The definitions of this scope (not its parents'): their names and signatures
+    const std::vector<std::pair<std::string, std::string>> &signatures() const;
+
+private:
+    std::shared_ptr<const Scope> parent_;
+    std::map<std::string, Definition> definitions_;
+    std::vector<std::pair<std::string, std::string>> signatures_;
+};
+
+}