ADD: float operators.

examples/float.fk

@@ -0,0 +1,20 @@
+(assert= 7.2 7.20)
+
+(assert= 4.7 (+. 3.2 1.5))
+(assert= 3.2 (+. 3.2))
+(assert= 0.0 (+.))
+
+(assert= 1.7 (-. 3.2 1.5))
+(assert= -1.5 (-. 1.5))
+(assert= 0.0 (-.))
+
+(assert= 77.4 (*. 21.5 3.6))
+(assert= 3.0 (*. 3.0))
+(assert= 1.0 (*.))
+
+(assert= 0.57 (/. 1.14 2.0))
+(assert= .25 (/. 4.0))
+(assert= 1.0 (/.))
+
+(assert= 1.5 (%. 75. 3.5))
+(assert= 15.625 (^. 2.5 3.))

libstd/fun.cpp

@@ -18,6 +18,24 @@
   return std::make_shared<Constant>(TYPE_BOOL, res, loc)
 
 
+#define FLOAT_OP(NEUTRAL, OP)                                           \
+  if (args.empty())                                                     \
+    {                                                                   \
+      return std::make_shared<Constant>(TYPE_FLOAT, NEUTRAL, loc);      \
+    }                                                                   \
+                                                                        \
+  float result = std::get<float>(args[0]->value());                     \
+                                                                        \
+  for (size_t i=1; i<args.size(); i++)                                  \
+    {                                                                   \
+      result = result OP std::get<float>(args[i]->value());             \
+    }                                                                   \
+  if (args.size() == 1)                                                 \
+    {                                                                   \
+      return std::make_shared<Constant>(TYPE_FLOAT, OP result, loc);    \
+    }                                                                   \
+  return std::make_shared<Constant>(TYPE_FLOAT, result, loc)
+
 namespace fkstd
 {
   STDRET assert_eq(Loc loc, Module&, STDARGS args)
@@ -166,6 +184,118 @@ namespace fkstd
     return std::make_shared<Constant>(TYPE_INT, result, loc);
   }
 
+  STDRET add_float(Loc loc, Module& mod, STDARGS args)
+  {
+    if (args.empty())
+      {
+        return std::make_shared<Constant>(TYPE_FLOAT, 0.0f, loc);
+      }
+
+    float result = std::get<float>(args[0]->value());
+
+    for (size_t i=1; i<args.size(); i++)
+      {
+        result = result + std::get<float>(args[i]->value());
+      }
+
+    return std::make_shared<Constant>(TYPE_FLOAT, result, loc);
+  }
+
+  STDRET sub_float(Loc loc, Module& mod, STDARGS args)
+  {
+    if (args.empty())
+      {
+        return std::make_shared<Constant>(TYPE_FLOAT, 0.0f, loc);
+      }
+
+    float result = std::get<float>(args[0]->value());
+
+    for (size_t i=1; i<args.size(); i++)
+      {
+        result = result - std::get<float>(args[i]->value());
+      }
+
+    if (args.size() == 1)
+      {
+        return std::make_shared<Constant>(TYPE_FLOAT, -result, loc);
+      }
+
+    return std::make_shared<Constant>(TYPE_FLOAT, result, loc);
+  }
+
+  STDRET mul_float(Loc loc, Module& mod, STDARGS args)
+  {
+    if (args.empty())
+      {
+        return std::make_shared<Constant>(TYPE_FLOAT, 1.0f, loc);
+      }
+
+    float result = std::get<float>(args[0]->value());
+
+    for (size_t i=1; i<args.size(); i++)
+      {
+        result = result * std::get<float>(args[i]->value());
+      }
+
+    return std::make_shared<Constant>(TYPE_FLOAT, result, loc);
+  }
+
+  STDRET div_float(Loc loc, Module& mod, STDARGS args)
+  {
+    if (args.empty())
+      {
+        return std::make_shared<Constant>(TYPE_FLOAT, 1.0f, loc);
+      }
+
+    float result = std::get<float>(args[0]->value());
+
+    for (size_t i=1; i<args.size(); i++)
+      {
+        result = result / std::get<float>(args[i]->value());
+      }
+
+    if (args.size() == 1)
+      {
+        return std::make_shared<Constant>(TYPE_FLOAT, 1.0f/result, loc);
+      }
+
+    return std::make_shared<Constant>(TYPE_FLOAT, result, loc);
+  }
+
+  STDRET mod_float(Loc loc, Module& mod, STDARGS args)
+  {
+    if (args.empty())
+      {
+        return std::make_shared<Constant>(TYPE_FLOAT, 1.0f, loc);
+      }
+
+    float result = std::get<float>(args[0]->value());
+
+    for (size_t i=1; i<args.size(); i++)
+      {
+        result = std::fmod(result, std::get<float>(args[i]->value()));
+      }
+
+    return std::make_shared<Constant>(TYPE_FLOAT, result, loc);
+  }
+
+  STDRET pow_float(Loc loc, Module& mod, STDARGS args)
+  {
+    if (args.empty())
+      {
+        return std::make_shared<Constant>(TYPE_FLOAT, 1.0f, loc);
+      }
+
+    float result = std::get<float>(args[0]->value());
+
+    for (size_t i=1; i<args.size(); i++)
+      {
+        result = std::pow(result, std::get<float>(args[i]->value()));
+      }
+
+    return std::make_shared<Constant>(TYPE_FLOAT, result, loc);
+  }
+
   STDRET lt(Loc loc, Module&, STDARGS args)
   {
     NUM_BINOP(<);

libstd/fun.hpp

@@ -14,6 +14,13 @@ namespace fkstd
   STDRET mod_int(Loc loc, Module& mod, STDARGS args);
   STDRET pow_int(Loc loc, Module& mod, STDARGS args);
 
+  STDRET add_float(Loc loc, Module& mod, STDARGS args);
+  STDRET sub_float(Loc loc, Module& mod, STDARGS args);
+  STDRET mul_float(Loc loc, Module& mod, STDARGS args);
+  STDRET div_float(Loc loc, Module& mod, STDARGS args);
+  STDRET mod_float(Loc loc, Module& mod, STDARGS args);
+  STDRET pow_float(Loc loc, Module& mod, STDARGS args);
+
   STDRET lt(Loc loc, Module& mod, STDARGS args);
   STDRET le(Loc loc, Module& mod, STDARGS args);
   STDRET gt(Loc loc, Module& mod, STDARGS args);

libstd/lib.cpp

@@ -12,6 +12,14 @@ extern "C" void lib(Module& mod)
   mod.register_function("/", fkstd::div_int);
   mod.register_function("%", fkstd::mod_int);
   mod.register_function("^", fkstd::pow_int);
+
+  mod.register_function("+.", fkstd::add_float);
+  mod.register_function("-.", fkstd::sub_float);
+  mod.register_function("*.", fkstd::mul_float);
+  mod.register_function("/.", fkstd::div_float);
+  mod.register_function("%.", fkstd::mod_float);
+  mod.register_function("^.", fkstd::pow_float);
+
   mod.register_function("<", fkstd::lt);
   mod.register_function("<=", fkstd::le);
   mod.register_function(">", fkstd::gt);

src/Lexer.cpp

@@ -196,7 +196,7 @@ namespace fk
         cursor++;
       }
 
-    if (repr.empty() || repr.back() == '-' || repr == ".")
+    if (repr.empty() || repr.back() == '-' || repr == "." || repr == "-.")
       {
         return std::nullopt;
       }