[Feat] 增加数学库 std.math

[Fix] 修复resolveModulePath解析二级模块的一些Bug

src/Module/builtins.hpp

@@ -3,11 +3,13 @@
 #include <Core/fig_string.hpp>
 #include <Value/value.hpp>
 
+#include <numeric>
 #include <unordered_map>
 #include <functional>
 #include <vector>
 #include <print>
 #include <iostream>
+#include <cmath>
 
 namespace Fig
 {
@@ -32,6 +34,36 @@ namespace Fig
             {u8"__fvalue_double_parse", 1},
             {u8"__fvalue_double_from", 1},
             {u8"__fvalue_string_from", 1},
+            /* math start */
+            {u8"__fmath_acos", 1},
+            {u8"__fmath_acosh", 1},
+            {u8"__fmath_asin", 1},
+            {u8"__fmath_asinh", 1},
+            {u8"__fmath_atan", 1},
+            {u8"__fmath_atan2", 2},
+            {u8"__fmath_atanh", 1},
+            {u8"__fmath_ceil", 1},
+            {u8"__fmath_cos", 1},
+            {u8"__fmath_cosh", 1},
+            {u8"__fmath_exp", 1},
+            {u8"__fmath_expm1", 1},
+            {u8"__fmath_fabs", 1},
+            {u8"__fmath_floor", 1},
+            {u8"__fmath_fmod", 2},
+            {u8"__fmath_frexp", 1},
+            {u8"__fmath_gcd", 2},
+            {u8"__fmath_hypot", 2},
+            {u8"__fmath_isequal", 2},
+            {u8"__fmath_log", 1},
+            {u8"__fmath_log10", 1},
+            {u8"__fmath_log1p", 1},
+            {u8"__fmath_log2", 1},
+            {u8"__fmath_sin", 1},
+            {u8"__fmath_sinh", 1},
+            {u8"__fmath_sqrt", 1},
+            {u8"__fmath_tan", 1},
+            {u8"__fmath_tanh", 1},
+            {u8"__fmath_trunc", 1},
         };
 
         const std::unordered_map<FString, BuiltinFunction> builtinFunctions{
@@ -121,7 +153,158 @@ namespace Fig
                  ObjectPtr val = args[0];
                  return std::make_shared<Object>(val->toString());
              }},
-
+             /* math start */
+            {u8"__fmath_acos", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(acos(d));
+             }},
+            {u8"__fmath_acosh", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(acosh(d));
+             }},
+            {u8"__fmath_asin", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(asin(d));
+             }},
+            {u8"__fmath_asinh", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(asinh(d));
+             }},
+            {u8"__fmath_atan", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(atan(d));
+             }},
+            {u8"__fmath_atan2", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ValueType::DoubleClass y = args[0]->getNumericValue();
+                 ValueType::DoubleClass x = args[1]->getNumericValue();
+                 return std::make_shared<Object>(atan2(y, x));
+             }},
+            {u8"__fmath_atanh", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(atanh(d));
+             }},
+            {u8"__fmath_ceil", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(ceil(d));
+             }},
+            {u8"__fmath_cos", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(cos(d));
+             }},
+            {u8"__fmath_cosh", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(cosh(d));
+             }},
+            {u8"__fmath_exp", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(exp(d));
+             }},
+            {u8"__fmath_expm1", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(expm1(d));
+             }},
+            {u8"__fmath_fabs", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(fabs(d));
+             }},
+            {u8"__fmath_floor", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(floor(d));
+             }},
+            {u8"__fmath_fmod", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ValueType::DoubleClass x = args[0]->getNumericValue();
+                 ValueType::DoubleClass y = args[1]->getNumericValue();
+                 return std::make_shared<Object>(fmod(x, y));
+             }},
+            {u8"__fmath_frexp", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 int e;
+                 return std::make_shared<Object>(List(
+                     {std::make_shared<Object>(frexp(d, &e)),
+                      std::make_shared<Object>(static_cast<ValueType::IntClass>(e))}));
+             }},
+            {u8"__fmath_gcd", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ValueType::IntClass x = args[0]->as<ValueType::IntClass>();
+                 ValueType::IntClass y = args[1]->as<ValueType::IntClass>();
+                 return std::make_shared<Object>(std::gcd(x, y));
+             }},
+            {u8"__fmath_hypot", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ValueType::DoubleClass x = args[0]->getNumericValue();
+                 ValueType::DoubleClass y = args[1]->getNumericValue();
+                 return std::make_shared<Object>(hypot(x, y));
+             }},
+            {u8"__fmath_isequal", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ValueType::DoubleClass x = args[0]->getNumericValue();
+                 ValueType::DoubleClass y = args[1]->getNumericValue();
+                 static const double epsilon = 1e-9;
+                 return std::make_shared<Object>(
+                    fabs(x - y) < epsilon
+                 );
+             }},
+            {u8"__fmath_log", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(log(d));
+             }},
+            {u8"__fmath_log10", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(log10(d));
+             }},
+            {u8"__fmath_log1p", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(log1p(d));
+             }},
+            {u8"__fmath_log2", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(log2(d));
+             }},
+            {u8"__fmath_sin", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(sin(d));
+             }},
+            {u8"__fmath_sinh", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(sinh(d));
+             }},
+            {u8"__fmath_sqrt", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(sqrt(d));
+             }},
+            {u8"__fmath_tan", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(tan(d));
+             }},
+            {u8"__fmath_tanh", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(tanh(d));
+             }},
+            {u8"__fmath_trunc", [](const std::vector<ObjectPtr> &args) -> ObjectPtr {
+                 ObjectPtr val = args[0];
+                 ValueType::DoubleClass d = val->getNumericValue();
+                 return std::make_shared<Object>(trunc(d));
+             }},
         };
 
         inline bool isBuiltinFunction(const FString &name)
@@ -149,4 +332,4 @@ namespace Fig
             return it->second;
         }
     }; // namespace Builtins
-}; // namespace Fig
+}; // namespace Fig.