started with opti

CMakeLists.txt

@@ -23,6 +23,7 @@ LINK_DIRECTORIES( ${Boost_LIBRARY_DIRS} )
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/json/single_include)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/cpp-httplib)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/exprtk)
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/sqlite3)
 
 add_subdirectory(lib)

lib/CMakeLists.txt

@@ -7,9 +7,9 @@ add_library(${PROJECT_NAME} STATIC
         include/HandlerModule
 	include/IConnector.h
         include/IInput.h
-        include/IListener.h
         include/IModule.h
         include/Input.h
+	include/IOptimizer.h
         include/IOutput.h
         include/IProcessor.h
 	include/IState.h
@@ -22,6 +22,8 @@ add_library(${PROJECT_NAME} STATIC
 	include/ModuleSplitt.h
         include/ModuleSQL.h
         include/ModuleSwitch.h
+	include/OptimizerBase.h
+	include/OptimizerEvolutionary.h
         include/Output.h
         include/ProcessorBase.h
         include/ProcessorEvolution.h
@@ -37,6 +39,8 @@ add_library(${PROJECT_NAME} STATIC
 	src/ModuleSplitt.cpp
         src/ModuleSQL.cpp
         src/ModuleSwitch.cpp
+	src/OptimizerBase.cpp
+	src/OptimizerEvolutionary.cpp
         src/Output.cpp
         src/ProcessorBase.cpp
 	src/ProcessorEvolution.cpp
@@ -49,6 +53,10 @@ target_include_directories(${PROJECT_NAME} PUBLIC
 
 target_link_libraries(${PROJECT_NAME} ${Boost_LIBRARIES} sqlite3)
 
+if(WIN32)
+	target_compile_options(${PROJECT_NAME} PRIVATE /bigobj)
+endif(WIN32)
+
 install(DIRECTORY include DESTINATION .)
 
 install(TARGETS ${PROJECT_NAME} DESTINATION lib/$<CONFIG> EXPORT targets)

lib/include/IOptimizer.h

@@ -0,0 +1,42 @@
+#ifndef IOPTIMIZER_H
+#define IOPTIMIZER_H
+#include "json.hpp"
+#include <IModule.h>
+
+namespace mdd {
+	class IOptimizer {
+		public:
+			virtual bool connect(std::shared_ptr<IModule> module) = 0;
+			/*
+			limit{
+				("min": []
+				"max": []
+				("increment": []
+				or
+				"rule": string))
+				nor
+				"elements": [[],[],[]]
+			}
+			*/
+			virtual bool addModifier(std::string input_id, const json& limit) = 0;
+			virtual bool addReader(std::string output_id) = 0;
+
+			/*
+			limit{
+				("min": []
+				"max": []
+				("increment": []
+				or
+				"rule": string))
+				nor
+				"elements": [[],[],[]]
+			}
+			*/
+			virtual bool changeModifier(std::string input_id, const json& limit) = 0;
+			virtual void removeModifier(std::string input_id) = 0;
+			virtual void removeReader(std::string output_id) = 0;
+			virtual bool setEvaluation(std::string func) = 0;
+			virtual state update() = 0;
+	};
+}
+#endif // !IOPTIMIZER_H

lib/include/OptimizerBase.h

@@ -0,0 +1,32 @@
+#ifndef OPTIMIZERBASE_H
+#define OPTIMIZERBASE_H
+#include "IOptimizer.h"
+#include "exprtk.hpp"
+
+namespace mdd {
+	class OptimizerBase : public IOptimizer {
+	protected:
+		std::shared_ptr<IModule> _module;
+		std::vector<std::shared_ptr<IInput>> _inputs;
+		std::vector<json> _input_limits;
+		std::vector<std::shared_ptr<IOutput>> _outputs;
+		std::vector<double> _output_vals;
+		exprtk::expression<double> _func_expr;
+
+		struct opt_state {
+			state module_state;
+			double opt_value = 0;
+		};
+		opt_state updateReader();
+
+	public:
+		bool addModifier(std::string input_id, const json& limit) override;
+		bool addReader(std::string output_id) override;
+		bool changeModifier(std::string input_id, const json& limit) override;
+		void removeModifier(std::string input_id) override;
+		void removeReader(std::string output_id) override;
+		bool setEvaluation(std::string func) override;
+		//state update() override;
+	};
+}
+#endif

lib/include/OptimizerEvolutionary.h

@@ -0,0 +1,47 @@
+#ifndef OPTIMIZEREVOLUTIONARY_H
+#define OPTIMIZEREVOLUTIONARY_H
+#include "OptimizerBase.h"
+
+namespace mdd {
+	class OptimizerEvolutionary : public OptimizerBase {
+	protected:
+		class Gene {
+		public:
+			json limit;
+			json value;
+			void mutate();
+			static void combine(Gene gene1, Gene gene2);
+		};
+
+		class DNA {
+		public:
+			json code;
+			void mutate();
+			void combine();
+			void applyDNA(std::vector<Gene>& genes);
+			static DNA generate(const std::vector<Gene>& genes);
+		};
+
+		class Individuum {
+		public:
+			DNA dna;
+			double fitness;
+
+		};
+
+		class Population {
+		public:
+			std::vector<Individuum> inivids:
+			std::vector<std::shared_ptr<Population>> grow(int size);
+
+		};
+
+		std::vector<Gene> _genes
+		Population _pops;
+
+	public:
+		OptimizerEvolutionary(std::shared_ptr<IModule> module);
+		state update() override;
+	};
+}
+#endif

lib/src/OptimizerBase.cpp

@@ -0,0 +1,97 @@
+#include "OptimizerBase.h"
+
+namespace mdd{
+	OptimizerBase::opt_state OptimizerBase::updateReader()
+	{
+		opt_state ret;
+		ret.module_state = _module->update();
+		if (ret.module_state != state::STATE_ERROR)
+		{
+			for (size_t i = 0; i < _output_vals.size(); ++i)
+			{
+				_output_vals[i] = _outputs[i]->getValue()["value"][0].get<double>();
+			}
+			ret.opt_value = _func_expr.value();
+		}
+		
+		return ret;
+	}
+
+	bool OptimizerBase::addModifier(std::string input_id, const json& limit)
+	{
+		if (_module != nullptr)
+		{
+			auto ptr = _module->getInput(input_id);
+			if (ptr != nullptr)
+			{
+				_inputs.push_back(ptr);
+				_input_limits.push_back(limit);
+				return true;
+			}
+		}
+		return false;
+	}
+
+	bool OptimizerBase::addReader(std::string output_id)
+	{	
+		if (_module != nullptr)
+		{
+			auto ptr = _module->getOutput(output_id);
+			if (ptr != nullptr)
+			{
+				_outputs.push_back(ptr);
+				_output_vals.push_back(ptr->getValue()["value"][0].get<double>());
+				return true;
+			}
+		}
+		return false;
+	}
+
+	bool OptimizerBase::changeModifier(std::string input_id, const json& limit)
+	{
+		for (size_t i = 0; i < _inputs.size(); i++)
+		{
+			if (_inputs[i]->getID() == input_id)
+			{
+				_input_limits[i] = limit;
+			}
+		}
+	}
+
+	void OptimizerBase::removeModifier(std::string input_id)
+	{
+		for (auto it = _inputs.begin(); it != _inputs.end(); ++it) {
+			if ((*it)->getID() == input_id)
+			{
+				_inputs.erase(it);
+			}
+		}
+	}
+	
+	void OptimizerBase::removeReader(std::string output_id)
+	{
+		for (auto it = _outputs.begin(); it != _outputs.end(); ++it) {
+			if ((*it)->getID() == output_id)
+			{
+				_outputs.erase(it);
+			}
+		}
+	}
+	
+	bool OptimizerBase::setEvaluation(std::string func)
+	{
+		exprtk::symbol_table<double> symbol_table;
+		for (size_t i = 0; i < _output_vals.size(); ++i)
+		{
+			symbol_table.add_variable("o"+i, _output_vals[i]);
+		}
+		symbol_table.add_constants();
+	
+		exprtk::expression<double> expression;
+		expression.register_symbol_table(symbol_table);
+	
+		exprtk::parser<double> parser;
+		return parser.compile(func, expression);
+	}
+	
+}

lib/src/OptimizerEvolutionary.cpp

@@ -0,0 +1,11 @@
+#include "OptimizerEvolutionary.h"
+
+namespace mdd {
+	OptimizerEvolutionary::OptimizerEvolutionary(std::shared_ptr<IModule> module)
+	{
+	}
+	state OptimizerEvolutionary::update()
+	{
+		return state();
+	}
+}

thirdparty/exprtk/Makefile

@@ -0,0 +1,54 @@
+#
+# **************************************************************
+# *         C++ Mathematical Expression Toolkit Library        *
+# *                                                            *
+# * Author: Arash Partow (1999-2020)                           *
+# * URL: http://www.partow.net/programming/exprtk/index.html   *
+# *                                                            *
+# * Copyright notice:                                          *
+# * Free use of the Mathematical Expression Toolkit Library is *
+# * permitted under the guidelines and in accordance with the  *
+# * most current version of the MIT License.                   *
+# * http://www.opensource.org/licenses/MIT                     *
+# *                                                            *
+# **************************************************************
+#
+
+
+COMPILER         := -c++
+#COMPILER        := -clang++
+OPTIMIZATION_OPT := -O1
+BASE_OPTIONS     := -pedantic-errors -Wall -Wextra -Werror -Wno-long-long
+OPTIONS          := $(BASE_OPTIONS) $(OPTIMIZATION_OPT)
+LINKER_OPT       := -L/usr/lib -lstdc++ -lm
+ASAN_OPT         := -g -fsanitize=address   -fno-omit-frame-pointer
+MSAN_OPT         := -g -fsanitize=memory    -fno-omit-frame-pointer
+LSAN_OPT         := -g -fsanitize=leak      -fno-omit-frame-pointer
+USAN_OPT         := -g -fsanitize=undefined -fno-omit-frame-pointer
+BUILD_SRC        := $(sort $(wildcard exprtk_*.cpp))
+BUILD_LIST       := $(BUILD_SRC:%.cpp=%)
+
+
+all: $(BUILD_LIST)
+
+$(BUILD_LIST) : %: %.cpp exprtk.hpp
+	$(COMPILER) $(OPTIONS) -o $@ $@.cpp $(LINKER_OPT)
+
+strip_bin :
+	@for f in $(BUILD_LIST); do if [ -f $$f ]; then strip -s $$f; echo $$f; fi done;
+
+valgrind :
+	@for f in $(BUILD_LIST); do \
+		if [ -f $$f ]; then \
+			cmd="valgrind --leak-check=full --show-reachable=yes --track-origins=yes --log-file=$$f.log -v ./$$f"; \
+			echo $$cmd; \
+			$$cmd; \
+		fi done;
+
+pgo: exprtk_benchmark.cpp exprtk.hpp
+	$(COMPILER) $(BASE_OPTIONS) -O3 -march=native -fprofile-generate -o exprtk_benchmark exprtk_benchmark.cpp $(LINKER_OPT)
+	./exprtk_benchmark
+	$(COMPILER) $(BASE_OPTIONS) -O3 -march=native -fprofile-use -o exprtk_benchmark exprtk_benchmark.cpp $(LINKER_OPT)
+
+clean:
+	rm -f core.* *~ *.o *.bak *stackdump gmon.out *.gcda *.gcno *.gcnor *.gch

thirdparty/exprtk/exprtk_benchmark.cpp

@@ -0,0 +1,564 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * ExprTk vs Native Benchmarks                                *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <cmath>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <deque>
+
+#include "exprtk.hpp"
+
+
+const std::string global_expression_list[]
+                     = {
+                          "(y + x)",
+                          "2 * (y + x)",
+                          "(2 * y + 2 * x)",
+                          "((1.23 * x^2) / y) - 123.123",
+                          "(y + x / y) * (x - y / x)",
+                          "x / ((x + y) + (x - y)) / y",
+                          "1 - ((x * y) + (y / x)) - 3",
+                          "(5.5 + x) + (2 * x - 2 / 3 * y) * (x / 3 + y / 4) + (y + 7.7)",
+                          "1.1x^1 + 2.2y^2 - 3.3x^3 + 4.4y^15 - 5.5x^23 + 6.6y^55",
+                          "sin(2 * x) + cos(pi / y)",
+                          "1 - sin(2 * x) + cos(pi / y)",
+                          "sqrt(111.111 - sin(2 * x) + cos(pi / y) / 333.333)",
+                          "(x^2 / sin(2 * pi / y)) - x / 2",
+                          "x + (cos(y - sin(2 / x * pi)) - sin(x - cos(2 * y / pi))) - y",
+                          "clamp(-1.0, sin(2 * pi * x) + cos(y / 2 * pi), +1.0)",
+                          "max(3.33, min(sqrt(1 - sin(2 * x) + cos(pi / y) / 3), 1.11))",
+                          "if((y + (x * 2.2)) <= (x + y + 1.1), x - y, x * y) + 2 * pi / x"
+                       };
+
+const std::size_t global_expression_list_size = sizeof(global_expression_list) / sizeof(std::string);
+
+static const double global_lower_bound_x = -100.0;
+static const double global_lower_bound_y = -100.0;
+static const double global_upper_bound_x = +100.0;
+static const double global_upper_bound_y = +100.0;
+static const double global_delta         = 0.0111;
+
+
+template <typename T,
+          typename Allocator,
+          template <typename,typename> class Sequence>
+bool load_expression(exprtk::symbol_table<T>& symbol_table,
+                     Sequence<exprtk::expression<T>,Allocator>& expr_seq)
+{
+   exprtk::parser<double> parser;
+
+   for (std::size_t i = 0; i < global_expression_list_size; ++i)
+   {
+      exprtk::expression<double> expression;
+      expression.register_symbol_table(symbol_table);
+
+      if (!parser.compile(global_expression_list[i],expression))
+      {
+         printf("[load_expression] - Parser Error: %s\tExpression: %s\n",
+                parser.error().c_str(),
+                global_expression_list[i].c_str());
+
+         return false;
+      }
+
+      expr_seq.push_back(expression);
+   }
+
+   return true;
+}
+
+template <typename T>
+void run_exprtk_benchmark(T& x, T& y,
+                          exprtk::expression<T>& expression,
+                          const std::string& expr_string)
+{
+   T total = T(0);
+   unsigned int count = 0;
+
+   exprtk::timer timer;
+   timer.start();
+
+   for (x = global_lower_bound_x; x <= global_upper_bound_x; x += global_delta)
+   {
+      for (y = global_lower_bound_y; y <= global_upper_bound_y; y += global_delta)
+      {
+         total += expression.value();
+         ++count;
+      }
+   }
+
+   timer.stop();
+
+   if (T(0) != total)
+      printf("[exprtk] Total Time:%12.8f  Rate:%14.3fevals/sec Expression: %s\n",
+             timer.time(),
+             count / timer.time(),
+             expr_string.c_str());
+   else
+      printf("run_exprtk_benchmark() - Error running benchmark for expression: %s\n",expr_string.c_str());
+}
+
+template <typename T> struct native;
+
+template <typename T, typename NativeFunction>
+void run_native_benchmark(T& x, T& y, NativeFunction f, const std::string& expr_string)
+{
+   T total = T(0);
+   unsigned int count = 0;
+
+   exprtk::timer timer;
+   timer.start();
+
+   for (x = global_lower_bound_x; x <= global_upper_bound_x; x += global_delta)
+   {
+      for (y = global_lower_bound_y; y <= global_upper_bound_y; y += global_delta)
+      {
+         total += f(x,y);
+         ++count;
+      }
+   }
+
+   timer.stop();
+
+   if (T(0) != total)
+      printf("[native] Total Time:%12.8f  Rate:%14.3fevals/sec Expression: %s\n",
+             timer.time(),
+             count / timer.time(),
+             expr_string.c_str());
+   else
+      printf("run_native_benchmark() - Error running benchmark for expression: %s\n",expr_string.c_str());
+}
+
+template <typename T>
+bool run_parse_benchmark(exprtk::symbol_table<T>& symbol_table)
+{
+   static const std::size_t rounds = 100000;
+   exprtk::parser<double> parser;
+   exprtk::expression<double> expression;
+
+   expression.register_symbol_table(symbol_table);
+
+   for (std::size_t i = 0; i < global_expression_list_size; ++i)
+   {
+      exprtk::timer timer;
+      timer.start();
+
+      for (std::size_t r = 0; r < rounds; ++r)
+      {
+         if (!parser.compile(global_expression_list[i],expression))
+         {
+            printf("[run_parse_benchmark] - Parser Error: %s\tExpression: %s\n",
+                   parser.error().c_str(),
+                   global_expression_list[i].c_str());
+
+            return false;
+         }
+      }
+
+      timer.stop();
+
+      printf("[parse] Total Time:%12.8f  Rate:%14.3fparse/sec Expression: %s\n",
+             timer.time(),
+             rounds / timer.time(),
+             global_expression_list[i].c_str());
+   }
+
+   return true;
+}
+
+const double pi = 3.141592653589793238462643383279502;
+
+template <typename T>
+struct native
+{
+   typedef typename exprtk::details::functor_t<T> functor_t;
+   typedef typename functor_t::Type Type;
+
+   static inline T avg(Type x, Type y)
+   {
+      return (x + y) / T(2);
+   }
+
+   static inline T clamp(const Type l, const Type v, const Type u)
+   {
+      return ((v < l) ? l : ((v > u) ? u : v));
+   }
+
+   static inline T func00(Type x, Type y)
+   {
+      return (y + x);
+   }
+
+   static inline T func01(Type x, Type y)
+   {
+      return T(2) * (y + x);
+   }
+
+   static inline T func02(Type x, Type y)
+   {
+      return (T(2) * y + T(2) * x);
+   }
+
+   static inline T func03(Type x, Type y)
+   {
+      return ((T(1.23) * (x * x)) / y) - T(123.123);
+   }
+
+   static inline T func04(Type x, Type y)
+   {
+      return (y + x / y) * (x - y / x);
+   }
+
+   static inline T func05(Type x, Type y)
+   {
+      return x / ((x + y) + (x - y)) / y;
+   }
+
+   static inline T func06(Type x, Type y)
+   {
+      return T(1) - ((x * y) + (y / x)) - T(3);
+   }
+
+   static inline T func07(Type x, Type y)
+   {
+      return (T(5.5) + x) + (T(2) * x - T(2) / T(3) * y) * (x / T(3) + y / T(4)) + (y + T(7.7));
+   }
+
+   static inline T func08(Type x, Type y)
+   {
+      using namespace std;
+      return (T(1.1)*pow(x,T(1))+T(2.2)*pow(y,T(2))-T(3.3)*pow(x,T(3))+T(4.4)*pow(y,T(15))-T(5.5)*pow(x,T(23))+T(6.6)*pow(y,T(55)));
+   }
+
+   static inline T func09(Type x, Type y)
+   {
+      return std::sin(T(2) * x) + std::cos(pi / y);
+   }
+
+   static inline T func10(Type x, Type y)
+   {
+      return T(1) - std::sin(T(2) * x) + std::cos(pi / y);
+   }
+
+   static inline T func11(Type x, Type y)
+   {
+      return std::sqrt(T(111.111) - std::sin(T(2) * x) + std::cos(pi / y) / T(333.333));
+   }
+
+   static inline T func12(Type x, Type y)
+   {
+      return ((x * x) / std::sin(T(2) * pi / y)) - x / T(2);
+   }
+
+   static inline T func13(Type x, Type y)
+   {
+      return (x + (std::cos(y - std::sin(T(2) / x * pi)) - std::sin(x - std::cos(T(2) * y / pi))) - y);
+   }
+
+   static inline T func14(Type x, Type y)
+   {
+      return clamp(T(-1), std::sin(T(2) * pi * x) + std::cos(y / T(2) * pi), + T(1));
+   }
+
+   static inline T func15(Type x, Type y)
+   {
+      return std::max(T(3.33), std::min(sqrt(T(1) - std::sin(T(2) * x) + std::cos(pi / y) / T(3)), T(1.11)));
+   }
+
+   static inline T func16(Type x, Type y)
+   {
+      return (((y + (x * T(2.2))) <= (x + y + T(1.1))) ? x - y : x * y) + T(2) * pi / x;
+   }
+};
+
+void pgo_primer();
+void perform_file_based_benchmark(const std::string& file_name, const std::size_t& rounds = 100000);
+
+int main(int argc, char* argv[])
+{
+   if (argc >= 2)
+   {
+      const std::string file_name = argv[1];
+
+      if (argc == 2)
+         perform_file_based_benchmark(file_name);
+      else
+         perform_file_based_benchmark(file_name,atoi(argv[2]));
+
+      return 0;
+   }
+
+   pgo_primer();
+
+   double x = 0;
+   double y = 0;
+
+   exprtk::symbol_table<double> symbol_table;
+   symbol_table.add_constants();
+   symbol_table.add_variable("x",x);
+   symbol_table.add_variable("y",y);
+
+   std::deque<exprtk::expression<double> > compiled_expr_list;
+
+   if (!load_expression(symbol_table,compiled_expr_list))
+   {
+      return 1;
+   }
+
+   {
+      std::cout << "--- EXPRTK ---" << std::endl;
+      for (std::size_t i = 0; i < compiled_expr_list.size(); ++i)
+      {
+         run_exprtk_benchmark(x,y,compiled_expr_list[i],global_expression_list[i]);
+      }
+   }
+
+   {
+      std::cout << "--- NATIVE ---" << std::endl;
+      run_native_benchmark(x,y,native<double>::func00,global_expression_list[ 0]);
+      run_native_benchmark(x,y,native<double>::func01,global_expression_list[ 1]);
+      run_native_benchmark(x,y,native<double>::func02,global_expression_list[ 2]);
+      run_native_benchmark(x,y,native<double>::func03,global_expression_list[ 3]);
+      run_native_benchmark(x,y,native<double>::func04,global_expression_list[ 4]);
+      run_native_benchmark(x,y,native<double>::func05,global_expression_list[ 5]);
+      run_native_benchmark(x,y,native<double>::func06,global_expression_list[ 6]);
+      run_native_benchmark(x,y,native<double>::func07,global_expression_list[ 7]);
+      run_native_benchmark(x,y,native<double>::func08,global_expression_list[ 8]);
+      run_native_benchmark(x,y,native<double>::func09,global_expression_list[ 9]);
+      run_native_benchmark(x,y,native<double>::func10,global_expression_list[10]);
+      run_native_benchmark(x,y,native<double>::func11,global_expression_list[11]);
+      run_native_benchmark(x,y,native<double>::func12,global_expression_list[12]);
+      run_native_benchmark(x,y,native<double>::func13,global_expression_list[13]);
+      run_native_benchmark(x,y,native<double>::func14,global_expression_list[14]);
+      run_native_benchmark(x,y,native<double>::func15,global_expression_list[15]);
+      run_native_benchmark(x,y,native<double>::func16,global_expression_list[16]);
+   }
+
+   {
+      std::cout << "--- PARSE ----" << std::endl;
+      run_parse_benchmark(symbol_table);
+   }
+
+   return 0;
+}
+
+void pgo_primer()
+{
+   exprtk::pgo_primer<double>();
+
+   static const double lower_bound_x = -50.0;
+   static const double lower_bound_y = -50.0;
+   static const double upper_bound_x = +50.0;
+   static const double upper_bound_y = +50.0;
+   static const double delta = 0.07;
+
+   double total = 0.0;
+
+   for (double x = lower_bound_x; x <= upper_bound_x; x += delta)
+   {
+      for (double y = lower_bound_y; y <= upper_bound_y; y += delta)
+      {
+         total += native<double>::func00(x,y);
+         total += native<double>::func01(x,y);
+         total += native<double>::func02(x,y);
+         total += native<double>::func03(x,y);
+         total += native<double>::func04(x,y);
+         total += native<double>::func05(x,y);
+         total += native<double>::func06(x,y);
+         total += native<double>::func07(x,y);
+         total += native<double>::func08(x,y);
+         total += native<double>::func09(x,y);
+         total += native<double>::func10(x,y);
+         total += native<double>::func11(x,y);
+         total += native<double>::func12(x,y);
+         total += native<double>::func13(x,y);
+         total += native<double>::func14(x,y);
+         total += native<double>::func15(x,y);
+         total += native<double>::func16(x,y);
+      }
+   }
+}
+
+std::size_t load_expression_file(const std::string& file_name, std::deque<std::string>& expression_list)
+{
+   std::ifstream stream(file_name.c_str());
+
+   if (!stream) return 0;
+
+   std::string buffer;
+   buffer.reserve(1024);
+   std::size_t line_count = 0;
+
+   while (std::getline(stream,buffer))
+   {
+      if (buffer.empty())
+         continue;
+      else if ('#' == buffer[0])
+         continue;
+
+      ++line_count;
+      expression_list.push_back(buffer);
+   }
+
+   return line_count;
+}
+
+void perform_file_based_benchmark(const std::string& file_name, const std::size_t& rounds)
+{
+   std::deque<std::string> expr_str_list;
+
+   if (0 == load_expression_file(file_name,expr_str_list))
+   {
+      std::cout << "Failed to load any expressions from: " << file_name << "\n";
+      return;
+   }
+
+   typedef exprtk::symbol_table<double> symbol_table_t;
+   typedef exprtk::expression<double>     expression_t;
+   typedef exprtk::parser<double>             parser_t;
+
+   std::deque<expression_t> expression_list;
+
+   symbol_table_t symbol_table;
+
+   double a = 1.1;
+   double b = 2.2;
+   double c = 3.3;
+   double x = 2.123456;
+   double y = 3.123456;
+   double z = 4.123456;
+   double w = 5.123456;
+
+   symbol_table.add_variable("a", a);
+   symbol_table.add_variable("b", b);
+   symbol_table.add_variable("c", c);
+
+   symbol_table.add_variable("x", x);
+   symbol_table.add_variable("y", y);
+   symbol_table.add_variable("z", z);
+   symbol_table.add_variable("w", w);
+
+   exprtk::polynomial<double, 1> poly01;
+   exprtk::polynomial<double, 2> poly02;
+   exprtk::polynomial<double, 3> poly03;
+   exprtk::polynomial<double, 4> poly04;
+   exprtk::polynomial<double, 5> poly05;
+   exprtk::polynomial<double, 6> poly06;
+   exprtk::polynomial<double, 7> poly07;
+   exprtk::polynomial<double, 8> poly08;
+   exprtk::polynomial<double, 9> poly09;
+   exprtk::polynomial<double,10> poly10;
+   exprtk::polynomial<double,11> poly11;
+   exprtk::polynomial<double,12> poly12;
+
+   symbol_table.add_function("poly01", poly01);
+   symbol_table.add_function("poly02", poly02);
+   symbol_table.add_function("poly03", poly03);
+   symbol_table.add_function("poly04", poly04);
+   symbol_table.add_function("poly05", poly05);
+   symbol_table.add_function("poly06", poly06);
+   symbol_table.add_function("poly07", poly07);
+   symbol_table.add_function("poly08", poly08);
+   symbol_table.add_function("poly09", poly09);
+   symbol_table.add_function("poly10", poly10);
+   symbol_table.add_function("poly11", poly11);
+   symbol_table.add_function("poly12", poly12);
+
+   static double e = exprtk::details::numeric::constant::e;
+   symbol_table.add_variable("e", e, true);
+
+   symbol_table.add_constants();
+
+   {
+      parser_t parser;
+
+      for (std::size_t i = 0; i < expr_str_list.size(); ++i)
+      {
+         expression_t expression;
+         expression.register_symbol_table(symbol_table);
+
+         if (!parser.compile(expr_str_list[i],expression))
+         {
+            printf("[perform_file_based_benchmark] - Parser Error: %s\tExpression: %s\n",
+                   parser.error().c_str(),
+                   expr_str_list[i].c_str());
+
+            return;
+         }
+
+         expression_list.push_back(expression);
+      }
+   }
+
+   exprtk::timer total_timer;
+   exprtk::timer timer;
+
+   double single_eval_total_time = 0.0;
+
+   total_timer.start();
+
+   for (std::size_t i = 0; i < expression_list.size(); ++i)
+   {
+      expression_t& expression = expression_list[i];
+
+      a = 1.1;
+      b = 2.2;
+      c = 3.3;
+      x = 2.123456;
+      y = 3.123456;
+      z = 4.123456;
+      w = 5.123456;
+
+      timer.start();
+      double sum = 0.0;
+
+      for (std::size_t r = 0; r < rounds; ++r)
+      {
+         sum += expression.value();
+         std::swap(a,b);
+         std::swap(x,y);
+      }
+
+      timer.stop();
+
+      printf("Expression %3d of %3d %9.3f ns\t%10d ns\t(%30.10f)  '%s'\n",
+             static_cast<int>(i + 1),
+             static_cast<int>(expression_list.size()),
+             (timer.time() * 1000000000.0) / (1.0 * rounds),
+             static_cast<int>(timer.time() * 1000000000.0),
+             sum,
+             expr_str_list[i].c_str());
+
+      fflush(stdout);
+
+      single_eval_total_time += (timer.time() * 1000000000.0) / (1.0 * rounds);
+   }
+
+   total_timer.stop();
+
+   printf("[*] Number Of Evals:        %15.0f\n",
+          rounds * (expression_list.size() * 1.0));
+
+   printf("[*] Total Time:             %9.3fsec\n",
+          total_timer.time());
+
+   printf("[*] Total Single Eval Time: %9.3fms\n",
+          single_eval_total_time / 1000000.0);
+}

thirdparty/exprtk/exprtk_simple_example_01.cpp

@@ -0,0 +1,58 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 1                                           *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void trig_function()
+{
+   typedef exprtk::symbol_table<T> symbol_table_t;
+   typedef exprtk::expression<T>     expression_t;
+   typedef exprtk::parser<T>             parser_t;
+
+   const std::string expression_string =
+                     "clamp(-1.0,sin(2 * pi * x) + cos(x / 2 * pi),+1.0)";
+
+   T x;
+
+   symbol_table_t symbol_table;
+   symbol_table.add_variable("x",x);
+   symbol_table.add_constants();
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(expression_string,expression);
+
+   for (x = T(-5); x <= T(+5); x += T(0.001))
+   {
+      const T y = expression.value();
+      printf("%19.15f\t%19.15f\n", x, y);
+   }
+}
+
+int main()
+{
+   trig_function<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_02.cpp

@@ -0,0 +1,73 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 2                                           *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void square_wave()
+{
+   typedef exprtk::symbol_table<T> symbol_table_t;
+   typedef exprtk::expression<T>     expression_t;
+   typedef exprtk::parser<T>             parser_t;
+
+   const std::string expr_string =
+                  "a*(4/pi)*"
+                  "((1 /1)*sin( 2*pi*f*t)+(1 /3)*sin( 6*pi*f*t)+"
+                  " (1 /5)*sin(10*pi*f*t)+(1 /7)*sin(14*pi*f*t)+"
+                  " (1 /9)*sin(18*pi*f*t)+(1/11)*sin(22*pi*f*t)+"
+                  " (1/13)*sin(26*pi*f*t)+(1/15)*sin(30*pi*f*t)+"
+                  " (1/17)*sin(34*pi*f*t)+(1/19)*sin(38*pi*f*t)+"
+                  " (1/21)*sin(42*pi*f*t)+(1/23)*sin(46*pi*f*t)+"
+                  " (1/25)*sin(50*pi*f*t)+(1/27)*sin(54*pi*f*t))";
+
+   static const T pi = T(3.141592653589793238462643383279502);
+
+   const T f = pi / T(10);
+   const T a = T(10);
+         T t = T(0);
+
+   symbol_table_t symbol_table;
+   symbol_table.add_variable("t",t);
+   symbol_table.add_constant("f",f);
+   symbol_table.add_constant("a",a);
+   symbol_table.add_constants();
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(expr_string,expression);
+
+   const T delta = (T(4) * pi) / T(1000);
+
+   for (t = (T(-2) * pi); t <= (T(+2) * pi); t += delta)
+   {
+      const T result = expression.value();
+      printf("%19.15f\t%19.15f\n", t, result);
+   }
+}
+
+int main()
+{
+   square_wave<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_03.cpp

@@ -0,0 +1,60 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 3                                           *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void polynomial()
+{
+   typedef exprtk::symbol_table<T> symbol_table_t;
+   typedef exprtk::expression<T>     expression_t;
+   typedef exprtk::parser<T>             parser_t;
+
+   const std::string expression_string =
+                  "25x^5 - 35x^4 - 15x^3 + 40x^2 - 15x + 1";
+
+   const T r0 = T(0);
+   const T r1 = T(1);
+         T  x = T(0);
+
+   symbol_table_t symbol_table;
+   symbol_table.add_variable("x",x);
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(expression_string,expression);
+
+   const T delta = T(1.0 / 100.0);
+
+   for (x = r0; x <= r1; x += delta)
+   {
+      printf("%19.15f\t%19.15f\n", x, expression.value());
+   }
+}
+
+int main()
+{
+   polynomial<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_04.cpp

@@ -0,0 +1,88 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 4                                           *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void fibonacci()
+{
+   typedef exprtk::symbol_table<T>      symbol_table_t;
+   typedef exprtk::expression<T>          expression_t;
+   typedef exprtk::parser<T>                  parser_t;
+   typedef exprtk::function_compositor<T> compositor_t;
+   typedef typename compositor_t::function  function_t;
+
+   compositor_t compositor;
+
+   compositor
+      .add(
+      function_t( // define function: fibonacci(x)
+           "fibonacci",
+           " var w := 0;             "
+           " var y := 0;             "
+           " var z := 1;             "
+           " switch                  "
+           " {                       "
+           "   case x == 0 : 0;      "
+           "   case x == 1 : 1;      "
+           "   default     :         "
+           "    while ((x -= 1) > 0) "
+           "    {                    "
+           "      w := z;            "
+           "      z := z + y;        "
+           "      y := w;            "
+           "      z                  "
+           "    };                   "
+           " }                       ",
+           "x"));
+
+   T x = T(0);
+
+   symbol_table_t& symbol_table = compositor.symbol_table();
+   symbol_table.add_constants();
+   symbol_table.add_variable("x",x);
+
+   std::string expression_str = "fibonacci(x)";
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(expression_str,expression);
+
+   for (std::size_t i = 0; i < 40; ++i)
+   {
+      x = static_cast<T>(i);
+
+      const T result = expression.value();
+
+      printf("fibonacci(%3d) = %10.0f\n",
+             static_cast<int>(i),
+             result);
+   }
+}
+
+int main()
+{
+   fibonacci<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_05.cpp

@@ -0,0 +1,81 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 5                                           *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+struct myfunc : public exprtk::ifunction<T>
+{
+   using exprtk::ifunction<T>::operator();
+
+   myfunc()
+   : exprtk::ifunction<T>(2)
+   { exprtk::disable_has_side_effects(*this); }
+
+   inline T operator()(const T& v1, const T& v2)
+   {
+      return T(1) + (v1 * v2) / T(3);
+   }
+};
+
+template <typename T>
+inline T myotherfunc(T v0, T v1, T v2)
+{
+   return std::abs(v0 - v1) * v2;
+}
+
+template <typename T>
+void custom_function()
+{
+   typedef exprtk::symbol_table<T> symbol_table_t;
+   typedef exprtk::expression<T>     expression_t;
+   typedef exprtk::parser<T>             parser_t;
+
+   const std::string expression_string =
+                  "myfunc(sin(x / pi), otherfunc(3 * y, x / 2, x * y))";
+
+   T x = T(1);
+   T y = T(2);
+   myfunc<T> mf;
+
+   symbol_table_t symbol_table;
+   symbol_table.add_variable("x",x);
+   symbol_table.add_variable("y",y);
+   symbol_table.add_function("myfunc",mf);
+   symbol_table.add_function("otherfunc",myotherfunc);
+   symbol_table.add_constants();
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(expression_string,expression);
+
+   const T result = expression.value();
+   printf("Result: %10.5f\n",result);
+}
+
+int main()
+{
+   custom_function<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_06.cpp

@@ -0,0 +1,60 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 6                                           *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void vector_function()
+{
+   typedef exprtk::symbol_table<T> symbol_table_t;
+   typedef exprtk::expression<T>     expression_t;
+   typedef exprtk::parser<T>             parser_t;
+
+   const std::string expression_string =
+                  " for (var i := 0; i < min(x[],y[],z[]); i += 1) "
+                  " {                                              "
+                  "   z[i] := 3sin(x[i]) + 2log(y[i]);             "
+                  " }                                              ";
+
+   T x[] = { T(1.1), T(2.2), T(3.3), T(4.4), T(5.5) };
+   T y[] = { T(1.1), T(2.2), T(3.3), T(4.4), T(5.5) };
+   T z[] = { T(0.0), T(0.0), T(0.0), T(0.0), T(0.0) };
+
+   symbol_table_t symbol_table;
+   symbol_table.add_vector("x",x);
+   symbol_table.add_vector("y",y);
+   symbol_table.add_vector("z",z);
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(expression_string,expression);
+
+   expression.value();
+}
+
+int main()
+{
+   vector_function<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_07.cpp

@@ -0,0 +1,71 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 7                                           *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void logic()
+{
+   typedef exprtk::symbol_table<T> symbol_table_t;
+   typedef exprtk::expression<T>     expression_t;
+   typedef exprtk::parser<T>             parser_t;
+
+   const std::string expression_string = "not(A and B) or C";
+
+   symbol_table_t symbol_table;
+   symbol_table.create_variable("A");
+   symbol_table.create_variable("B");
+   symbol_table.create_variable("C");
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(expression_string,expression);
+
+   printf(" # | A | B | C | %s\n"
+          "---+---+---+---+-%s\n",
+          expression_string.c_str(),
+          std::string(expression_string.size(),'-').c_str());
+
+   for (int i = 0; i < 8; ++i)
+   {
+      symbol_table.get_variable("A")->ref() = T((i & 0x01) ? 1 : 0);
+      symbol_table.get_variable("B")->ref() = T((i & 0x02) ? 1 : 0);
+      symbol_table.get_variable("C")->ref() = T((i & 0x04) ? 1 : 0);
+
+      const int result = static_cast<int>(expression.value());
+
+      printf(" %d | %d | %d | %d | %d \n",
+             i,
+             static_cast<int>(symbol_table.get_variable("A")->value()),
+             static_cast<int>(symbol_table.get_variable("B")->value()),
+             static_cast<int>(symbol_table.get_variable("C")->value()),
+             result);
+   }
+}
+
+int main()
+{
+   logic<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_08.cpp

@@ -0,0 +1,90 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 8                                           *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void composite()
+{
+   typedef exprtk::symbol_table<T>      symbol_table_t;
+   typedef exprtk::expression<T>          expression_t;
+   typedef exprtk::parser<T>                  parser_t;
+   typedef exprtk::parser_error::type            err_t;
+   typedef exprtk::function_compositor<T> compositor_t;
+   typedef typename compositor_t::function  function_t;
+
+   compositor_t compositor;
+
+   T x = T(1);
+   T y = T(2);
+
+   symbol_table_t& symbol_table = compositor.symbol_table();
+   symbol_table.add_constants();
+   symbol_table.add_variable("x",x);
+   symbol_table.add_variable("y",y);
+
+   compositor
+      .add(
+      function_t("f","sin(x / pi)","x"));          // f(x) = sin(x / pi)
+
+   compositor
+      .add(
+      function_t("g","3*[f(x) + f(y)]","x","y"));  // g(x,y) = 3[f(x) + f(y)]
+
+   std::string expression_string = "g(1 + f(x), f(y) / 2)";
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+
+   if (!parser.compile(expression_string,expression))
+   {
+      printf("Error: %s\tExpression: %s\n",
+             parser.error().c_str(),
+             expression_string.c_str());
+
+      for (std::size_t i = 0; i < parser.error_count(); ++i)
+      {
+         const err_t error = parser.get_error(i);
+
+         printf("Error: %02d  Position: %02d Type: [%14s] Msg: %s\tExpression: %s\n",
+                static_cast<unsigned int>(i),
+                static_cast<unsigned int>(error.token.position),
+                exprtk::parser_error::to_str(error.mode).c_str(),
+                error.diagnostic.c_str(),
+                expression_string.c_str());
+      }
+
+      return;
+   }
+
+   const T result = expression.value();
+
+   printf("%s = %e\n", expression_string.c_str(), result);
+}
+
+int main()
+{
+   composite<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_09.cpp

@@ -0,0 +1,152 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 9                                           *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void primes()
+{
+   typedef exprtk::symbol_table<T>      symbol_table_t;
+   typedef exprtk::expression<T>          expression_t;
+   typedef exprtk::parser<T>                  parser_t;
+   typedef exprtk::function_compositor<T> compositor_t;
+   typedef typename compositor_t::function  function_t;
+
+   T x = T(0);
+
+   symbol_table_t symbol_table;
+
+   symbol_table.add_constants();
+   symbol_table.add_variable("x",x);
+
+   compositor_t compositor(symbol_table);
+
+   //Mode 1 - if statement based
+   compositor
+      .add(
+      function_t( // define function: is_prime_impl1(x,y)
+           "is_prime_impl1",
+           " if (y == 1,true,                "
+           "    if (0 == (x % y),false,      "
+           "       is_prime_impl1(x,y - 1))) ",
+           "x","y"));
+
+   compositor
+      .add(
+      function_t( // define function: is_prime1(x)
+           "is_prime1",
+           " if (frac(x) != 0, false,                                "
+           "    if (x <= 0, false,                                   "
+           "       is_prime_impl1(x,min(x - 1,trunc(sqrt(x)) + 1)))) ",
+           "x"));
+
+   //Mode 2 - switch statement based
+   compositor
+      .add(
+      function_t( // define function: is_prime_impl2(x,y)
+           "is_prime_impl2",
+           " switch                                         "
+           " {                                              "
+           "   case y == 1       : true;                    "
+           "   case (x % y) == 0 : false;                   "
+           "   default           : is_prime_impl2(x,y - 1); "
+           " }                                              ",
+           "x","y"));
+
+   compositor
+      .add(
+      function_t( // define function: is_prime2(x)
+           "is_prime2",
+           " switch                                                                 "
+           " {                                                                      "
+           "   case x <= 0       : false;                                           "
+           "   case frac(x) != 0 : false;                                           "
+           "   default           : is_prime_impl2(x,min(x - 1,trunc(sqrt(x)) + 1)); "
+           " }                                                                      ",
+           "x"));
+
+   //Mode 3 - switch statement and while-loop based
+   compositor
+      .add(
+      function_t( // define function: is_prime_impl3(x,y)
+           "is_prime_impl3",
+           " while (y > 0)                            "
+           " {                                        "
+           "   switch                                 "
+           "   {                                      "
+           "     case y == 1       : ~(y := 0,true);  "
+           "     case (x % y) == 0 : ~(y := 0,false); "
+           "     default           : y := y - 1;      "
+           "   }                                      "
+           " }                                        ",
+           "x","y"));
+
+   compositor
+      .add(
+      function_t( // define function: is_prime3(x)
+           "is_prime3",
+           " switch                                                                 "
+           " {                                                                      "
+           "   case x <= 0       : false;                                           "
+           "   case frac(x) != 0 : false;                                           "
+           "   default           : is_prime_impl3(x,min(x - 1,trunc(sqrt(x)) + 1)); "
+           " }                                                                      ",
+           "x"));
+
+   std::string expression_str1 = "is_prime1(x)";
+   std::string expression_str2 = "is_prime2(x)";
+   std::string expression_str3 = "is_prime3(x)";
+
+   expression_t expression1;
+   expression_t expression2;
+   expression_t expression3;
+   expression1.register_symbol_table(symbol_table);
+   expression2.register_symbol_table(symbol_table);
+   expression3.register_symbol_table(symbol_table);
+
+   parser_t parser;
+
+   parser.compile(expression_str1,expression1);
+   parser.compile(expression_str2,expression2);
+   parser.compile(expression_str3,expression3);
+
+   for (std::size_t i = 0; i < 100; ++i)
+   {
+      x = static_cast<T>(i);
+
+      const T result1 = expression1.value();
+      const T result2 = expression2.value();
+      const T result3 = expression3.value();
+
+      printf("%03d  Result1: %c  Result2: %c  Result3: %c\n",
+             static_cast<unsigned int>(i),
+             (result1 == T(1)) ? 'T' : 'F',
+             (result2 == T(1)) ? 'T' : 'F',
+             (result3 == T(1)) ? 'T' : 'F');
+   }
+}
+
+int main()
+{
+   primes<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_10.cpp

@@ -0,0 +1,92 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 10                                          *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cmath>
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void newton_sqrt()
+{
+   typedef exprtk::symbol_table<T>      symbol_table_t;
+   typedef exprtk::expression<T>          expression_t;
+   typedef exprtk::parser<T>                  parser_t;
+   typedef exprtk::function_compositor<T> compositor_t;
+   typedef typename compositor_t::function  function_t;
+
+   T x = T(0);
+
+   symbol_table_t symbol_table;
+
+   symbol_table.add_constants();
+   symbol_table.add_variable("x",x);
+
+   compositor_t compositor(symbol_table);
+
+   compositor
+      .add(
+      function_t( // define function: newton_sqrt(x)
+           "newton_sqrt",
+           " switch                                                "
+           " {                                                     "
+           "   case x < 0  : null;                                 "
+           "   case x == 0 : 0;                                    "
+           "   case x == 1 : 1;                                    "
+           "   default:                                            "
+           "   ~{                                                  "
+           "      var z := 100;                                    "
+           "      var sqrt_x := x / 2;                             "
+           "      repeat                                           "
+           "        if (equal(sqrt_x^2, x))                        "
+           "          break[sqrt_x];                               "
+           "        else                                           "
+           "          sqrt_x := (1 / 2) * (sqrt_x + (x / sqrt_x)); "
+           "      until ((z -= 1) <= 0);                           "
+           "    };                                                 "
+           " }                                                     ",
+           "x"));
+
+   const std::string expression_str = "newton_sqrt(x)";
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(expression_str,expression);
+
+   for (std::size_t i = 0; i < 100; ++i)
+   {
+      x = static_cast<T>(i);
+
+      const T result = expression.value();
+
+      printf("sqrt(%03d) - Result: %15.13f\tReal: %15.13f\n",
+             static_cast<unsigned int>(i),
+             result,
+             std::sqrt(x));
+   }
+}
+
+int main()
+{
+   newton_sqrt<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_11.cpp

@@ -0,0 +1,71 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 11                                          *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void square_wave2()
+{
+   typedef exprtk::symbol_table<T> symbol_table_t;
+   typedef exprtk::expression<T>     expression_t;
+   typedef exprtk::parser<T>             parser_t;
+
+   const std::string wave_program =
+                  " var r := 0;                                         "
+                  " for (var i := 0; i < 1000; i += 1)                  "
+                  " {                                                   "
+                  "   r += (1 / (2i + 1)) * sin((4i + 2) * pi * f * t); "
+                  " };                                                  "
+                  " r *= a * (4 / pi);                                  ";
+
+   static const T pi = T(3.141592653589793238462643383279502);
+
+   T f = pi / T(10);
+   T t = T(0);
+   T a = T(10);
+
+   symbol_table_t symbol_table;
+   symbol_table.add_variable("f",f);
+   symbol_table.add_variable("t",t);
+   symbol_table.add_variable("a",a);
+   symbol_table.add_constants();
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(wave_program,expression);
+
+   const T delta = (T(4) * pi) / T(1000);
+
+   for (t = (T(-2) * pi); t <= (T(+2) * pi); t += delta)
+   {
+      const T result = expression.value();
+      printf("%19.15f\t%19.15f\n", t, result);
+   }
+}
+
+int main()
+{
+   square_wave2<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_12.cpp

@@ -0,0 +1,69 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 12                                          *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void bubble_sort()
+{
+   typedef exprtk::symbol_table<T> symbol_table_t;
+   typedef exprtk::expression<T>     expression_t;
+   typedef exprtk::parser<T>             parser_t;
+
+   const std::string bubblesort_program =
+                  " var upper_bound := v[];                           "
+                  " var swapped := false;                             "
+                  " repeat                                            "
+                  "   swapped := false;                               "
+                  "   for (var i := 0; i < upper_bound; i += 1)       "
+                  "   {                                               "
+                  "     for (var j := i + 1; j < upper_bound; j += 1) "
+                  "     {                                             "
+                  "       if (v[i] > v[j])                            "
+                  "       {                                           "
+                  "         v[i] <=> v[j];                            "
+                  "         swapped := true;                          "
+                  "       };                                          "
+                  "     };                                            "
+                  "   };                                              "
+                  "   upper_bound -= 1;                               "
+                  " until (not(swapped) or (upper_bound == 0));       ";
+
+   T v[] = { T(9.9), T(2.2), T(1.1), T(5.5), T(7.7), T(4.4), T(3.3) };
+
+   symbol_table_t symbol_table;
+   symbol_table.add_vector("v",v);
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(bubblesort_program,expression);
+
+   expression.value();
+}
+
+int main()
+{
+   bubble_sort<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_13.cpp

@@ -0,0 +1,100 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 13                                          *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <cstdlib>
+#include <ctime>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void savitzky_golay_filter()
+{
+   typedef exprtk::symbol_table<T> symbol_table_t;
+   typedef exprtk::expression<T>     expression_t;
+   typedef exprtk::parser<T>             parser_t;
+
+   const std::string sgfilter_program =
+                  " var weight[9] :=                                          "
+                  "       {                                                   "
+                  "         -21, 14,  39,                                     "
+                  "          54, 59,  54,                                     "
+                  "          39, 14, -21                                      "
+                  "       };                                                  "
+                  "                                                           "
+                  " if (v_in[] >= weight[])                                   "
+                  " {                                                         "
+                  "   var lower_bound := trunc(weight[] / 2);                 "
+                  "   var upper_bound := v_in[] - lower_bound;                "
+                  "                                                           "
+                  "   v_out := 0;                                             "
+                  "                                                           "
+                  "   for (var i := lower_bound; i < upper_bound; i += 1)     "
+                  "   {                                                       "
+                  "     for (var j := -lower_bound; j <= lower_bound; j += 1) "
+                  "     {                                                     "
+                  "       v_out[i] += weight[j + lower_bound] * v_in[i + j];  "
+                  "     };                                                    "
+                  "   };                                                      "
+                  "                                                           "
+                  "   v_out /= sum(weight);                                   "
+                  " }                                                         ";
+
+   const std::size_t n = 1024;
+
+   std::vector<T> v_in;
+   std::vector<T> v_out;
+
+   const T pi = T(3.141592653589793238462643383279502);
+
+   srand(static_cast<unsigned int>(time(0)));
+
+   // Generate a signal with noise.
+   for (T t = T(-5); t <= T(+5); t += T(10.0 / n))
+   {
+      T noise = T(0.5 * (rand() / (RAND_MAX + 1.0) - 0.5));
+      v_in.push_back(sin(2.0 * pi * t) + noise);
+   }
+
+   v_out.resize(v_in.size());
+
+   symbol_table_t symbol_table;
+   symbol_table.add_vector("v_in" , v_in);
+   symbol_table.add_vector("v_out",v_out);
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(sgfilter_program,expression);
+
+   expression.value();
+
+   for (std::size_t i = 0; i < v_out.size(); ++i)
+   {
+      printf("%10.6f\t%10.6f\n",v_in[i],v_out[i]);
+   }
+}
+
+int main()
+{
+   savitzky_golay_filter<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_14.cpp

@@ -0,0 +1,56 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 14                                          *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void stddev_example()
+{
+   typedef exprtk::expression<T> expression_t;
+   typedef exprtk::parser<T>         parser_t;
+
+   const std::string stddev_program =
+                  " var x[25] := {                     "
+                  "                 1,  2,  3,  4,  5, "
+                  "                 6,  7,  8,  9, 10, "
+                  "                11, 12, 13, 14, 15, "
+                  "                16, 17, 18, 19, 20, "
+                  "                21, 22, 23, 24, 25  "
+                  "              };                    "
+                  "                                    "
+                  " sqrt(sum([x - avg(x)]^2) / x[])    ";
+
+   expression_t expression;
+
+   parser_t parser;
+   parser.compile(stddev_program,expression);
+
+   const T stddev = expression.value();
+
+   printf("stddev(1..25) = %10.6f\n",stddev);
+}
+
+int main()
+{
+   stddev_example<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_15.cpp

@@ -0,0 +1,94 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 15                                          *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void black_scholes_merton_model()
+{
+   typedef exprtk::symbol_table<T> symbol_table_t;
+   typedef exprtk::expression<T>     expression_t;
+   typedef exprtk::parser<T>             parser_t;
+
+   const std::string bsm_model_program =
+                  " var d1 := (log(s / x) + (r + v^2 / 2) * t) / (v * sqrt(t)); "
+                  " var d2 := d1 - v * sqrt(t);                                 "
+                  "                                                             "
+                  " if (callput_flag == 'call')                                 "
+                  "   s * ncdf(d1) - x * e^(-r * t) * ncdf(d2);                 "
+                  " else if (callput_flag == 'put')                             "
+                  "   x * e^(-r * t) * ncdf(-d2) - s * ncdf(-d1);               "
+                  "                                                             ";
+
+   T s = T(60.00); // Stock price
+   T x = T(65.00); // Strike price
+   T t = T( 0.25); // Years to maturity
+   T r = T( 0.08); // Risk free rate
+   T v = T( 0.30); // Volatility
+
+   std::string callput_flag;
+
+   static const T e = exprtk::details::numeric::constant::e;
+
+   symbol_table_t symbol_table;
+   symbol_table.add_variable("s",s);
+   symbol_table.add_variable("x",x);
+   symbol_table.add_variable("t",t);
+   symbol_table.add_variable("r",r);
+   symbol_table.add_variable("v",v);
+   symbol_table.add_constant("e",e);
+   symbol_table.add_stringvar("callput_flag",callput_flag);
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(bsm_model_program,expression);
+
+   {
+      callput_flag = "call";
+
+      T bsm = expression.value();
+
+      printf("BSM(%s,%5.3f,%5.3f,%5.3f,%5.3f,%5.3f) = %10.6f\n",
+             callput_flag.c_str(),
+             s, x, t, r, v,
+             bsm);
+   }
+
+   {
+      callput_flag = "put";
+
+      T bsm = expression.value();
+
+      printf("BSM(%s,%5.3f,%5.3f,%5.3f,%5.3f,%5.3f) = %10.6f\n",
+             callput_flag.c_str(),
+             s, x, t, r, v,
+             bsm);
+   }
+}
+
+int main()
+{
+   black_scholes_merton_model<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_16.cpp

@@ -0,0 +1,82 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 16                                          *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <cstdlib>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void linear_least_squares()
+{
+   typedef exprtk::symbol_table<T> symbol_table_t;
+   typedef exprtk::expression<T>     expression_t;
+   typedef exprtk::parser<T>             parser_t;
+
+   const std::string linear_least_squares_program =
+                  " if (x[] == y[])                                       "
+                  " {                                                     "
+                  "   beta  := (sum(x * y) - sum(x) * sum(y) / x[]) /     "
+                  "            (sum(x^2) -  sum(x)^2 / x[]);              "
+                  "                                                       "
+                  "   alpha := avg(y) - beta * avg(x);                    "
+                  "                                                       "
+                  "   rmse  := sqrt(sum((beta * x + alpha - y)^2) / y[]); "
+                  " }                                                     "
+                  " else                                                  "
+                  " {                                                     "
+                  "   alpha := null;                                      "
+                  "   beta  := null;                                      "
+                  "   rmse  := null;                                      "
+                  " }                                                     ";
+
+   T x[] = {T(  1), T(  2), T(3), T(  4), T(  5), T(6), T(  7), T(  8), T(  9), T(10)};
+   T y[] = {T(8.7), T(6.8), T(6), T(5.6), T(3.8), T(3), T(2.4), T(1.7), T(0.4), T(-1)};
+
+   T alpha = T(0);
+   T beta  = T(0);
+   T rmse  = T(0);
+
+   symbol_table_t symbol_table;
+   symbol_table.add_variable("alpha",alpha);
+   symbol_table.add_variable("beta" ,beta );
+   symbol_table.add_variable("rmse" ,rmse );
+   symbol_table.add_vector  ("x"    ,x    );
+   symbol_table.add_vector  ("y"    ,y    );
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(linear_least_squares_program,expression);
+
+   expression.value();
+
+   printf("alpha: %15.12f\n",alpha);
+   printf("beta:  %15.12f\n",beta );
+   printf("rmse:  %15.12f\n",rmse );
+   printf("y = %15.12fx + %15.12f\n",beta,alpha);
+}
+
+int main()
+{
+   linear_least_squares<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_17.cpp

@@ -0,0 +1,78 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 17                                          *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <cstdlib>
+#include <ctime>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+struct rnd_01 : public exprtk::ifunction<T>
+{
+   using exprtk::ifunction<T>::operator();
+
+   rnd_01() : exprtk::ifunction<T>(0)
+   { ::srand(static_cast<unsigned int>(time(NULL))); }
+
+   inline T operator()()
+   {
+      // Note: Do not use this in production
+      // Result is in the interval [0,1)
+      return T(::rand() / T(RAND_MAX + 1.0));
+   }
+};
+
+template <typename T>
+void monte_carlo_pi()
+{
+   typedef exprtk::symbol_table<T> symbol_table_t;
+   typedef exprtk::expression<T>     expression_t;
+   typedef exprtk::parser<T>             parser_t;
+
+   const std::string monte_carlo_pi_program =
+                  " var experiments[5 * 10^7] := [(rnd_01^2 + rnd_01^2) <= 1]; "
+                  " 4 * sum(experiments) / experiments[];                      ";
+
+   rnd_01<T> rnd01;
+
+   symbol_table_t symbol_table;
+   symbol_table.add_function("rnd_01",rnd01);
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(monte_carlo_pi_program,expression);
+
+   const T approximate_pi = expression.value();
+
+   const T real_pi = T(3.141592653589793238462643383279502); // or close enough...
+
+   printf("pi ~ %20.17f\terror: %20.17f\n",
+          approximate_pi,
+          std::abs(real_pi - approximate_pi));
+}
+
+int main()
+{
+   monte_carlo_pi<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_18.cpp

@@ -0,0 +1,79 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 18                                          *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+void file_io()
+{
+   typedef exprtk::symbol_table<T> symbol_table_t;
+   typedef exprtk::expression<T>     expression_t;
+   typedef exprtk::parser<T>             parser_t;
+
+   const std::string fileio_program =
+                " var file_name := 'file.txt';                         "
+                " var stream    := null;                               "
+                "                                                      "
+                " if (stream := open(file_name,'w'))                   "
+                "   println('Successfully opened file: ' + file_name); "
+                " else                                                 "
+                " {                                                    "
+                "   println('Failed to open file: ' + file_name);      "
+                "   return [false];                                    "
+                " }                                                    "
+                "                                                      "
+                " var s := 'Hello world...\n';                         "
+                "                                                      "
+                " for (var i := 0; i < 10; i += 1)                     "
+                " {                                                    "
+                "   write(stream,s);                                   "
+                " }                                                    "
+                "                                                      "
+                " if (close(stream))                                   "
+                "   println('Sucessfully closed file: ' + file_name);  "
+                " else                                                 "
+                " {                                                    "
+                "   println('Failed to close file: ' + file_name);     "
+                "   return [false];                                    "
+                " }                                                    ";
+
+   exprtk::rtl::io::file::package<T> fileio_package;
+   exprtk::rtl::io::println<T>       println;
+
+   symbol_table_t symbol_table;
+   symbol_table.add_function("println",println);
+   symbol_table.add_package (fileio_package   );
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(fileio_program,expression);
+
+   printf("Result %10.3f\n",expression.value());
+}
+
+int main()
+{
+   file_io<double>();
+   return 0;
+}

thirdparty/exprtk/exprtk_simple_example_19.cpp

@@ -0,0 +1,129 @@
+/*
+ **************************************************************
+ *         C++ Mathematical Expression Toolkit Library        *
+ *                                                            *
+ * Simple Example 19                                          *
+ * Author: Arash Partow (1999-2020)                           *
+ * URL: http://www.partow.net/programming/exprtk/index.html   *
+ *                                                            *
+ * Copyright notice:                                          *
+ * Free use of the Mathematical Expression Toolkit Library is *
+ * permitted under the guidelines and in accordance with the  *
+ * most current version of the MIT License.                   *
+ * http://www.opensource.org/licenses/MIT                     *
+ *                                                            *
+ **************************************************************
+*/
+
+
+#include <cstdio>
+#include <cstdlib>
+#include <ctime>
+#include <string>
+
+#include "exprtk.hpp"
+
+
+template <typename T>
+class randu : public exprtk::igeneric_function<T>
+{
+public:
+
+   typedef typename exprtk::igeneric_function<T> igfun_t;
+   typedef typename igfun_t::parameter_list_t    parameter_list_t;
+   typedef typename igfun_t::generic_type        generic_type;
+   typedef typename generic_type::vector_view    vector_t;
+
+   using exprtk::igeneric_function<T>::operator();
+
+   randu()
+   : exprtk::igeneric_function<T>("V|VTT")
+      /*
+         Overloads:
+         0. V   - vector
+         1. VTT - vector, r0, r1
+      */
+   { ::srand(static_cast<unsigned int>(time(NULL))); }
+
+   inline T operator()(const std::size_t& ps_index, parameter_list_t parameters)
+   {
+      vector_t v(parameters[0]);
+
+      std::size_t r0 = 0;
+      std::size_t r1 = v.size() - 1;
+
+      if (
+           (1 == ps_index) &&
+           !exprtk::rtl::vecops::helper::
+              load_vector_range<T>::process(parameters,r0,r1,1,2,0)
+         )
+         return T(0);
+
+      for (std::size_t i = r0; i <= r1; ++i)
+      {
+         v[i] = rnd();
+      }
+
+      return T(1);
+   }
+
+private:
+
+   inline T rnd()
+   {
+      // Note: Do not use this in production
+      // Result is in the interval [0,1)
+      return T(::rand() / T(RAND_MAX + 1.0));
+   }
+};
+
+template <typename T>
+void vector_randu()
+{
+   typedef exprtk::symbol_table<T> symbol_table_t;
+   typedef exprtk::expression<T>     expression_t;
+   typedef exprtk::parser<T>             parser_t;
+
+   const std::string vecrandu_program =
+                " var noise[6] := [0];                     "
+                "                                          "
+                " if (randu(noise,0,5) == false)           "
+                " {                                        "
+                "   println('Failed to generate noise');   "
+                "   return [false];                        "
+                " }                                        "
+                "                                          "
+                " var noisy[6] := signal + (noise - 1/2);  "
+                "                                          "
+                " for (var i := 0; i < noisy[]; i += 1)    "
+                " {                                        "
+                "   println('noisy[',i,'] = ', noisy[i]);  "
+                " }                                        "
+                "                                          "
+                " println('avg: ', avg(noisy));            "
+                "                                          ";
+
+   T signal[] = { T(1.1), T(2.2), T(3.3), T(4.4), T(5.5), T(6.6), T(7.7) };
+
+   exprtk::rtl::io::println<T> println;
+   randu<T>                    randu;
+
+   symbol_table_t symbol_table;
+   symbol_table.add_vector  ("signal" , signal);
+   symbol_table.add_function("println",println);
+   symbol_table.add_function("randu"  ,  randu);
+
+   expression_t expression;
+   expression.register_symbol_table(symbol_table);
+
+   parser_t parser;
+   parser.compile(vecrandu_program,expression);
+
+   expression.value();
+}
+
+int main()
+{
+   vector_randu<double>();
+   return 0;
+}