From 5d86274da2013756ac551a92fe425f91729a578e Mon Sep 17 00:00:00 2001
From: Samuel Pfrommer <sam.pfrommer@gmail.com>
Date: Sun, 22 Mar 2015 16:42:47 -0400
Subject: [PATCH] Finished implement all cmath functions

---
 include/chaiscript/extras/math.hpp | 579 ++++++++++++++++++++++++++++-
 tests/math.cpp                     |  65 +++-
 2 files changed, 628 insertions(+), 16 deletions(-)

diff --git a/include/chaiscript/extras/math.hpp b/include/chaiscript/extras/math.hpp
index 5e3fb8d..b5faba1 100644
--- a/include/chaiscript/extras/math.hpp
+++ b/include/chaiscript/extras/math.hpp
@@ -1,20 +1,13 @@
 #include <cmath>
 #include <memory>
 
-#include <chaiscript/chaiscript.hpp>
+#include "../dispatchkit/dispatchkit.hpp"
+#include "../chaiscript.hpp"
 
 namespace chaiscript {
   namespace extras {
     namespace math {
-      template<typename Ret, typename Param>
-      ModulePtr floor(ModulePtr m = std::make_shared<Module>())
-      {
-        // using the overloads provided by C++11
-        // http://www.cplusplus.com/reference/cmath/floor/
-        m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::floor)), "floor");
-        return m;
-      }
-
+      // TRIG FUNCTIONS
       template<typename Ret, typename Param>
       ModulePtr cos(ModulePtr m = std::make_shared<Module>())
       {
@@ -64,6 +57,7 @@ namespace chaiscript {
         return m;
       }
 
+      // HYPERBOLIC FUNCTIONS
       template<typename Ret, typename Param>
       ModulePtr cosh(ModulePtr m = std::make_shared<Module>())
       {
@@ -106,6 +100,105 @@ namespace chaiscript {
         return m;
       }
 
+      // EXPONENTIAL AND LOGARITHMIC FUNCTIONS
+      template<typename Ret, typename Param>
+      ModulePtr exp(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::exp)), "exp");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr frexp(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::frexp)), "frexp");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr ldexp(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::ldexp)), "ldexp");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr log(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::log)), "log");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr log10(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::log10)), "log10");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr modf(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::modf)), "modf");
+    	  return m;
+      }
+      template<typename Ret, typename Param>
+      ModulePtr exp2(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::exp2)), "exp2");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr expm1(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::expm1)), "expm1");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr ilogb(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::ilogb)), "ilogb");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr log1p(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::log1p)), "log1p");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr log2(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::log2)), "log2");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr logb(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::logb)), "logb");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr scalbn(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::scalbn)), "scalbn");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr scalbln(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::scalbln)), "scalbln");
+    	  return m;
+      }
+
+      // POWER FUNCTIONS
       template<typename Ret, typename Param1, typename Param2>
       ModulePtr pow(ModulePtr m = std::make_shared<Module>())
       {
@@ -134,6 +227,7 @@ namespace chaiscript {
         return m;
       }
 
+      // ERROR AND GAMMA FUNCTIONS
       template<typename Ret, typename Param>
       ModulePtr erf(ModulePtr m = std::make_shared<Module>())
       {
@@ -162,12 +256,263 @@ namespace chaiscript {
         return m;
       }
 
-      ModulePtr bootstrap(ModulePtr m = std::make_shared<Module>())
+      // ROUNDING AND REMAINDER FUNCTIONS
+      template<typename Ret, typename Param>
+      ModulePtr ceil(ModulePtr m = std::make_shared<Module>())
       {
-        floor<double, double>(m);
-        floor<long double, long double>(m);
-        floor<float, float>(m);
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::ceil)), "ceil");
+		  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr floor(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::floor)), "floor");
+		  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr fmod(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::fmod)), "fmod");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr trunc(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::trunc)), "trunc");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr round(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::round)), "round");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr lround(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::lround)), "lround");
+    	  return m;
+      }
+
+      // long long ints do not work
+      /*template<typename Ret, typename Param>
+      ModulePtr llround(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::llround)), "llround");
+    	  return m;
+      }*/
+
+      template<typename Ret, typename Param>
+      ModulePtr rint(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::rint)), "rint");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr lrint(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::lrint)), "lrint");
+    	  return m;
+      }
+
+      // long long ints do not work
+      /*template<typename Ret, typename Param>
+      ModulePtr llrint(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::llrint)), "llrint");
+    	  return m;
+      }*/
+
+      template<typename Ret, typename Param>
+      ModulePtr nearbyint(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::nearbyint)), "nearbyint");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr remainder(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::remainder)), "remainder");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2, typename Param3>
+      ModulePtr remquo(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2, Param3)>(&std::remquo)), "remquo");
+    	  return m;
+      }
+
+      // FLOATING-POINT MANIPULATION FUNCTIONS
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr copysign(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::copysign)), "copysign");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr nan(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::nan)), "nan");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr nextafter(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::nextafter)), "nextafter");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr nexttoward(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::nexttoward)), "nexttoward");
+    	  return m;
+      }
+
+      // MINIMUM, MAXIMUM, DIFFERENCE FUNCTIONS
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr fdim(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::fdim)), "fdim");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr fmax(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::fmax)), "fmax");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr fmin(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::fmin)), "fmin");
+    	  return m;
+      }
+
+      // OTHER FUNCTIONS
+      template<typename Ret, typename Param>
+      ModulePtr fabs(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::fabs)), "fabs");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr abs(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::abs)), "abs");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2, typename Param3>
+      ModulePtr fma(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2, Param3)>(&std::fma)), "fma");
+    	  return m;
+      }
+
+      // CLASSIFICATION FUNCTIONS
+      template<typename Ret, typename Param>
+      ModulePtr fpclassify(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::fpclassify)), "fpclassify");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr isfinite(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::isfinite)), "isfinite");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr isinf(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::isinf)), "isinf");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr isnan(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::isnan)), "isnan");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr isnormal(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::isnormal)), "isnormal");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param>
+      ModulePtr signbit(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param)>(&std::signbit)), "signbit");
+    	  return m;
+      }
+
+
+      // COMPARISON FUNCTIONS
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr isgreater(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::isgreater)), "isgreater");
+    	  return m;
+      }
 
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr isgreaterequal(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::isgreaterequal)), "isgreaterequal");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr isless(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::isless)), "isless");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr islessequal(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::islessequal)), "islessequal");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr islessgreater(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::islessgreater)), "islessgreater");
+    	  return m;
+      }
+
+      template<typename Ret, typename Param1, typename Param2>
+      ModulePtr isunordered(ModulePtr m = std::make_shared<Module>())
+      {
+    	  m->add(chaiscript::fun(static_cast<Ret (*)(Param1, Param2)>(&std::isunordered)), "isunordered");
+    	  return m;
+      }
+
+      ModulePtr bootstrap(ModulePtr m = std::make_shared<Module>())
+      {
+    	// TRIG FUNCTIONS
         cos<double, double>(m);
         cos<float, float>(m);
         cos<long double, long double>(m);
@@ -196,6 +541,7 @@ namespace chaiscript {
         atan2<float, float, float>(m);
         atan2<long double, long double, long double>(m);
 
+        // HYPERBOLIC FUNCTIONS
         cosh<double, double>(m);
         cosh<float, float>(m);
         cosh<long double, long double>(m);
@@ -220,6 +566,64 @@ namespace chaiscript {
         atanh<float, float>(m);
         atanh<long double, long double>(m);
 
+        // EXPONENTIAL AND LOGARITHMIC FUNCTIONS
+        exp<double, double>(m);
+        exp<float, float>(m);
+        exp<long double, long double>(m);
+
+        frexp<double, double, int *>(m);
+        frexp<float, float, int *>(m);
+        frexp<long double, long double, int *>(m);
+
+        ldexp<double, double, int>(m);
+        ldexp<float, float, int>(m);
+        ldexp<long double, long double, int>(m);
+
+        log<double, double>(m);
+        log<float, float>(m);
+        log<long double, long double>(m);
+
+        log10<double, double>(m);
+        log10<float, float>(m);
+        log10<long double, long double>(m);
+
+        modf<double, double, double *>(m);
+        modf<float, float, float *>(m);
+        modf<long double, long double, long double *>(m);
+
+        exp2<double, double>(m);
+        exp2<float, float>(m);
+        exp2<long double, long double>(m);
+
+        expm1<double, double>(m);
+        expm1<float, float>(m);
+        expm1<long double, long double>(m);
+
+        ilogb<int, double>(m);
+        ilogb<int, float>(m);
+        ilogb<int, long double>(m);
+
+        log1p<double, double>(m);
+        log1p<float, float>(m);
+        log1p<long double, long double>(m);
+
+        log2<double, double>(m);
+        log2<float, float>(m);
+        log2<long double, long double>(m);
+
+        logb<double, double>(m);
+        logb<float, float>(m);
+        logb<long double, long double>(m);
+
+        scalbn<double, double, int>(m);
+        scalbn<float, float, int>(m);
+        scalbn<long double, long double, int>(m);
+
+        scalbln<double, double, long int>(m);
+        scalbln<float, float, long int>(m);
+        scalbln<long double, long double, long int>(m);
+
+        // POWER FUNCTIONS
         pow<double, double, double>(m);
         pow<float, float, float>(m);
         pow<long double, long double, long double>(m);
@@ -236,6 +640,7 @@ namespace chaiscript {
         hypot<float, float, float>(m);
         hypot<long double, long double, long double>(m);
 
+        // ERROR AND GAMMA FUNCTIONS
         erf<double, double>(m);
         erf<float, float>(m);
         erf<long double, long double>(m);
@@ -252,6 +657,152 @@ namespace chaiscript {
         lgamma<float, float>(m);
         lgamma<long double, long double>(m);
 
+        // ROUNDING AND REMAINDER FUNCTIONS
+        ceil<double, double>(m);
+        ceil<float, float>(m);
+        ceil<long double, long double>(m);
+
+        floor<double, double>(m);
+        floor<float, float>(m);
+        floor<long double, long double>(m);
+
+        fmod<double, double, double>(m);
+        fmod<float, float, float>(m);
+        fmod<long double, long double, long double>(m);
+
+        trunc<double, double>(m);
+        trunc<float, float>(m);
+        trunc<long double, long double>(m);
+
+        round<double, double>(m);
+        round<float, float>(m);
+        round<long double, long double>(m);
+
+        lround<long int, double>(m);
+        lround<long int, float>(m);
+        lround<long int, long double>(m);
+
+        // long long ints do not work
+        /*llround<long long int, double>(m);
+        llround<long long int, float>(m);
+        llround<long long int, long double>(m);*/
+
+        rint<double, double>(m);
+        rint<float, float>(m);
+        rint<long double, long double>(m);
+
+        lrint<long int, double>(m);
+        lrint<long int, float>(m);
+        lrint<long int, long double>(m);
+
+        // long long ints do not work
+        /*llrint<long long int, double>(m);
+        llrint<long long int, float>(m);
+        llrint<long long int, long double>(m);*/
+
+        nearbyint<double, double>(m);
+        nearbyint<float, float>(m);
+        nearbyint<long double, long double>(m);
+
+        remainder<double, double, double>(m);
+        remainder<float, float, float>(m);
+        remainder<long double, long double, long double>(m);
+
+        remquo<double, double, double, int *>(m);
+        remquo<float, float, float, int *>(m);
+        remquo<long double, long double, long double, int *>(m);
+
+        // FLOATING-POINT MANIPULATION FUNCTIONS
+        copysign<double, double, double>(m);
+        copysign<float, float, float>(m);
+        copysign<long double, long double, long double>(m);
+
+        nan<double, const char*>(m);
+
+        nextafter<double, double, double>(m);
+        nextafter<float, float, float>(m);
+        nextafter<long double, long double, long double>(m);
+
+        nexttoward<double, double, long double>(m);
+        nexttoward<float, float, long double>(m);
+        nexttoward<long double, long double, long double>(m);
+
+        // MINIMUM, MAXIMUM, DIFFERENCE FUNCTIONS
+        fdim<double, double, double>(m);
+        fdim<float, float, float>(m);
+        fdim<long double, long double, long double>(m);
+
+        fmax<double, double, double>(m);
+        fmax<float, float, float>(m);
+        fmax<long double, long double, long double>(m);
+
+        fmin<double, double, double>(m);
+        fmin<float, float, float>(m);
+        fmin<long double, long double, long double>(m);
+
+        // OTHER FUNCTIONS
+        fabs<double, double>(m);
+        fabs<float, float>(m);
+        fabs<long double, long double>(m);
+
+        abs<double, double>(m);
+        abs<float, float>(m);
+        abs<long double, long double>(m);
+
+        fma<double, double, double, double>(m);
+        fma<float, float, float, float>(m);
+        fma<long double, long double, long double, long double>(m);
+
+        // CLASSIFICATION FUNCTIONS
+        fpclassify<int, float>(m);
+        fpclassify<int, double>(m);
+        fpclassify<int, long double>(m);
+
+        isfinite<bool, float>(m);
+        isfinite<bool, double>(m);
+        isfinite<bool, long double>(m);
+
+        isinf<bool, float>(m);
+        isinf<bool, double>(m);
+        isinf<bool, long double>(m);
+
+        isnan<bool, float>(m);
+        isnan<bool, double>(m);
+        isnan<bool, long double>(m);
+
+        isnormal<bool, float>(m);
+        isnormal<bool, double>(m);
+        isnormal<bool, long double>(m);
+
+        signbit<bool, float>(m);
+        signbit<bool, double>(m);
+        signbit<bool, long double>(m);
+
+        // COMPARISON FUNCTIONS
+        isgreater<bool, double, double>(m);
+        isgreater<bool, float, float>(m);
+        isgreater<bool, long double, long double>(m);
+
+        isgreaterequal<bool, double, double>(m);
+        isgreaterequal<bool, float, float>(m);
+        isgreaterequal<bool, long double, long double>(m);
+
+        isless<bool, double, double>(m);
+        isless<bool, float, float>(m);
+        isless<bool, long double, long double>(m);
+
+        islessequal<bool, double, double>(m);
+        islessequal<bool, float, float>(m);
+        islessequal<bool, long double, long double>(m);
+
+        islessgreater<bool, double, double>(m);
+        islessgreater<bool, float, float>(m);
+        islessgreater<bool, long double, long double>(m);
+
+        isunordered<bool, double, double>(m);
+        isunordered<bool, float, float>(m);
+        isunordered<bool, long double, long double>(m);
+
         return m;
       }
     }
diff --git a/tests/math.cpp b/tests/math.cpp
index 8d2a0cf..bdf43ce 100644
--- a/tests/math.cpp
+++ b/tests/math.cpp
@@ -5,6 +5,8 @@
 #include <chaiscript/chaiscript_stdlib.hpp>
 #include "../include/chaiscript/extras/math.hpp"
 
+#include <iostream>
+
 TEST_CASE( "Math functions work", "[math]" ) {
   auto stdlib = chaiscript::Std_Lib::library();
   auto mathlib = chaiscript::extras::math::bootstrap();
@@ -12,8 +14,7 @@ TEST_CASE( "Math functions work", "[math]" ) {
   chaiscript::ChaiScript chai(stdlib);
   chai.add(mathlib);
 
-  CHECK(chai.eval<double>("floor(2.2)") == floor(2.2));
-
+  // TRIG FUNCTIONS
   CHECK(chai.eval<double>("cos(0.5)") == cos(0.5));
   CHECK(chai.eval<double>("sin(0.5)") == sin(0.5));
   CHECK(chai.eval<double>("tan(0.5)") == tan(0.5));
@@ -23,6 +24,7 @@ TEST_CASE( "Math functions work", "[math]" ) {
   CHECK(chai.eval<double>("atan(0.5)") == atan(0.5));
   CHECK(chai.eval<double>("atan2(0.5, 0.5)") == atan2(0.5, 0.5));
 
+  // HYPERBOLIC FUNCTIONS
   CHECK(chai.eval<double>("cosh(0.5)") == cosh(0.5));
   CHECK(chai.eval<double>("sinh(0.5)") == sinh(0.5));
   CHECK(chai.eval<double>("tanh(0.5)") == tanh(0.5));
@@ -31,15 +33,74 @@ TEST_CASE( "Math functions work", "[math]" ) {
   CHECK(chai.eval<double>("asinh(0.5)") == asinh(0.5));
   CHECK(chai.eval<double>("atanh(0.5)") == atanh(0.5));
 
+  // EXPONENTIAL AND LOGARITHMIC FUNCTIONS
+  CHECK(chai.eval<double>("exp(0.5)") == exp(0.5));
+  int exp = 0; CHECK(chai.eval<double>("var exp = 2\nfrexp(0.5, exp)") == frexp(0.5, &exp));
+  CHECK(chai.eval<double>("ldexp(0.5, 2)") == ldexp(0.5, 2));
+  CHECK(chai.eval<double>("log(0.5)") == log(0.5));
+  CHECK(chai.eval<double>("log10(0.5)") == log10(0.5));
+  double ipart = 0.5; CHECK(chai.eval<double>("var ipart = 0.5\nmodf(0.5, ipart)") == modf(0.5, &ipart));
+  CHECK(chai.eval<double>("exp2(0.5)") == exp2(0.5));
+  CHECK(chai.eval<double>("expm1(0.5)") == expm1(0.5));
+  CHECK(chai.eval<int>("ilogb(0.5)") == ilogb(0.5));
+  CHECK(chai.eval<double>("log1p(0.5)") == log1p(0.5));
+  CHECK(chai.eval<double>("log2(0.5)") == log2(0.5));
+  CHECK(chai.eval<double>("logb(0.5)") == ilogb(0.5));
+  CHECK(chai.eval<double>("scalbn(0.5, 2)") == scalbn(0.5, 2));
+  CHECK(chai.eval<double>("scalbln(0.5, 2l)") == scalbln(0.5, 2));
+
+  // POWER FUNCTIONS
   CHECK(chai.eval<double>("pow(0.5, 3.0)") == pow(0.5, 3.0));
   CHECK(chai.eval<double>("sqrt(0.5)") == sqrt(0.5));
   CHECK(chai.eval<double>("cbrt(0.5)") == cbrt(0.5));
   CHECK(chai.eval<double>("hypot(0.5, 0.5)") == hypot(0.5, 0.5));
 
+  // ERROR AND GAMMA FUNCTIONS
   CHECK(chai.eval<double>("erf(0.5)") == erf(0.5));
   CHECK(chai.eval<double>("erfc(0.5)") == erfc(0.5));
   CHECK(chai.eval<double>("tgamma(0.5)") == tgamma(0.5));
   CHECK(chai.eval<double>("lgamma(0.5)") == lgamma(0.5));
+
+  // ROUNDING AND REMAINDER FUNCTIONS
+  CHECK(chai.eval<double>("ceil(0.5)") == ceil(0.5));
+  CHECK(chai.eval<double>("floor(0.5)") == floor(0.5));
+  CHECK(chai.eval<double>("fmod(0.5, 0.5)") == fmod(0.5, 0.5));
+  CHECK(chai.eval<double>("trunc(0.5)") == trunc(0.5));
+  CHECK(chai.eval<double>("round(0.5)") == round(0.5));
+  CHECK(chai.eval<long int>("lround(0.5)") == lround(0.5));
+  // CHECK(chai.eval<double>("llround(0.5)") == llround(0.5)); // long longs do not work
+  CHECK(chai.eval<double>("rint(0.5)") == rint(0.5));
+  CHECK(chai.eval<long int>("lrint(0.5)") == lrint(0.5));
+  // CHECK(chai.eval<double>("llrint(0.5)") == llrint(0.5));
+  CHECK(chai.eval<double>("nearbyint(0.5)") == nearbyint(0.5));
+  CHECK(chai.eval<double>("remainder(6.0, 2.5)") == remainder(6.0, 2.5));
+  int quot = 0; CHECK(chai.eval<double>("var quot = 0\nremquo(6.0, 2.5, quot)") == remquo(6.0, 2.5, &quot));
+
+  // MINIMUM, MAXIMUM, DIFFERENCE FUNCTIONS
+  CHECK(chai.eval<double>("fdim(6.0, 2.5)") == fdim(6.0, 2.5));
+  CHECK(chai.eval<double>("fmax(6.0, 2.5)") == fmax(6.0, 2.5));
+  CHECK(chai.eval<double>("fmin(6.0, 2.5)") == fmin(6.0, 2.5));
+
+  // OTHER FUNCTIONS
+  CHECK(chai.eval<double>("fabs(-0.5)") == fabs(-0.5));
+  CHECK(chai.eval<double>("abs(-0.5)") == std::abs(-0.5));
+  CHECK(chai.eval<double>("fma(0.5, 0.5, 0.5)") == fma(0.5, 0.5, 0.5));
+
+  // CLASSIFICATION FUNCTIONS
+  CHECK(chai.eval<int>("fpclassify(0.5)") == std::fpclassify(0.5));
+  CHECK(chai.eval<bool>("isfinite(0.5)") == std::isfinite(0.5));
+  CHECK(chai.eval<bool>("isinf(0.5)") == std::isinf(0.5));
+  CHECK(chai.eval<bool>("isnan(0.5)") == std::isnan(0.5));
+  CHECK(chai.eval<bool>("isnormal(0.5)") == std::isnormal(0.5));
+  CHECK(chai.eval<bool>("signbit(0.5)") == std::signbit(0.5));
+
+  // COMPARISON FUNCTIONS
+  CHECK(chai.eval<bool>("isgreater(1.0, 0.5)") == std::isgreater(1.0, 0.5));
+  CHECK(chai.eval<bool>("isgreaterequal(1.0, 0.5)") == std::isgreaterequal(1.0, 0.5));
+  CHECK(chai.eval<bool>("isless(1.0, 0.5)") == std::isless(1.0, 0.5));
+  CHECK(chai.eval<bool>("islessequal(1.0, 0.5)") == std::islessequal(1.0, 0.5));
+  CHECK(chai.eval<bool>("islessgreater(1.0, 0.5)") == std::islessgreater(1.0, 0.5));
+  CHECK(chai.eval<bool>("isunordered(1.0, 0.5)") == std::isunordered(1.0, 0.5));
 }