xfygogo
/
exprtk
mirror of https://github.com/ArashPartow/exprtk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fixups for psp

This commit is contained in:
Arash Partow 2024-01-01 00:00:00 +00:00
parent ddafbfe57a
commit a5a1e23396
33 changed files with 443 additions and 70335 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
.circleci/config.yml
View File

@ -1,102 +0,0 @@
version: 2.1
jobs:
build_gcc_09:
docker:
- image: gcc:9
steps:
- checkout
- run: c++ --version
- run: make all -j 2
- run: ./exprtk_test
build_gcc_10:
docker:
- image: gcc:10
steps:
- checkout
- run: c++ --version
- run: make all -j 2
- run: ./exprtk_test
build_gcc_11:
docker:
- image: gcc:11
steps:
- checkout
- run: c++ --version
- run: make all -j 2
- run: ./exprtk_test
build_gcc_12:
docker:
- image: gcc:12
steps:
- checkout
- run: c++ --version
- run: make all -j 2
- run: ./exprtk_test
build_gcc_13:
docker:
- image: gcc:13
steps:
- checkout
- run: c++ --version
- run: make all -j 2
- run: ./exprtk_test
build_gcc_latest:
docker:
- image: gcc:latest
steps:
- checkout
- run: c++ --version
- run: make all -j 2
- run: ./exprtk_test
workflows:
version: 2
build_and_test:
jobs:
- build_gcc_09:
filters:
branches:
only:
- master
- release
- build_gcc_10:
filters:
branches:
only:
- master
- release
- build_gcc_11:
filters:
branches:
only:
- master
- release
- build_gcc_12:
filters:
branches:
only:
- master
- release
- build_gcc_13:
filters:
branches:
only:
- master
- release
- build_gcc_latest:
filters:
branches:
only:
- master
- release

55
Makefile
View File

@ -1,55 +0,0 @@
#
# **************************************************************
# * C++ Mathematical Expression Toolkit Library *
# * *
# * Author: Arash Partow (1999-2024) *
# * URL: https://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. *
# * https://www.opensource.org/licenses/MIT *
# * SPDX-License-Identifier: MIT *
# * *
# **************************************************************
#
COMPILER := -c++
#COMPILER := -clang++
OPTIMIZATION_OPT := -O2 -DNDEBUG
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 -DNDEBUG -march=native -fprofile-generate -o exprtk_benchmark exprtk_benchmark.cpp $(LINKER_OPT)
./exprtk_benchmark
$(COMPILER) $(BASE_OPTIONS) -O3 -DNDEBUG -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

728
exprtk.hpp
View File

File diff suppressed because it is too large Load Diff

569
exprtk_benchmark.cpp
View File

@ -1,569 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* ExprTk vs Native Benchmarks *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: MIT *
* *
**************************************************************
*/
#include <cstdio>
#include <cmath>
#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;
}
};
double 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;
}
{
printf("--- EXPRTK ---\n");
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]);
}
}
{
printf("--- NATIVE ---\n");
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]);
}
{
printf("--- PARSE ----\n");
run_parse_benchmark(symbol_table);
}
return 0;
}
double pgo_primer()
{
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);
}
}
return total;
}
inline 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))
{
printf("Failed to load any expressions from: %s\n", file_name.c_str());
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;
exprtk::rtl::vecops::package<double> vector_package;
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);
symbol_table.add_package(vector_package);
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);
}

37872
exprtk_functional_ext_test.txt
View File

File diff suppressed because it is too large Load Diff

10206
exprtk_functional_test.txt
View File

File diff suppressed because it is too large Load Diff

59
exprtk_simple_example_01.cpp
View File

@ -1,59 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 01 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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;
}

74
exprtk_simple_example_02.cpp
View File

@ -1,74 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 02 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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 expression_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(expression_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;
}

61
exprtk_simple_example_03.cpp
View File

@ -1,61 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 03 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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;
}

90
exprtk_simple_example_04.cpp
View File

@ -1,90 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 04 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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;
T x = T(0);
compositor_t compositor;
compositor.add(
function_t("fibonacci")
.var("x")
.expression
(
" switch "
" { "
" case x == 0 : 0; "
" case x == 1 : 1; "
" default : "
" { "
" var prev := 0; "
" var curr := 1; "
" while ((x -= 1) > 0) "
" { "
" var temp := prev; "
" prev := curr; "
" curr += temp; "
" }; "
" }; "
" } "
));
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;
}

82
exprtk_simple_example_05.cpp
View File

@ -1,82 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 05 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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); }
T operator()(const T& v1, const T& v2)
{
return T(1) + (v1 * v2) / T(3);
}
};
template <typename T>
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;
}

61
exprtk_simple_example_06.cpp
View File

@ -1,61 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 06 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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;
}

72
exprtk_simple_example_07.cpp
View File

@ -1,72 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 07 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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;
}

93
exprtk_simple_example_08.cpp
View File

@ -1,93 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 08 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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;
T x = T(1);
T y = T(2);
compositor_t compositor;
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") // f(x) = sin(x / pi)
.var("x")
.expression( "sin(x / pi)" ));
compositor.add(
function_t("g") // g(x,y) = 3[f(x) + f(y)]
.vars("x", "y")
.expression( "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;
}

180
exprtk_simple_example_09.cpp
View File

@ -1,180 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 09 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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("is_prime_impl1")
.vars("x", "y")
.expression
(
" if (y == 1,true, "
" if (0 == (x % y),false, "
" is_prime_impl1(x,y - 1))) "
));
compositor.add(
function_t("is_prime1")
.var("x")
.expression
(
" if (frac(x) != 0) "
" return [false]; "
" else if (x <= 0) "
" return [false]; "
" else "
" is_prime_impl1(x,min(x - 1,trunc(sqrt(x)) + 1)); "
));
//Mode 2 - switch statement based
compositor.add(
function_t("is_prime_impl2")
.vars("x", "y")
.expression
(
" switch "
" { "
" case y == 1 : true; "
" case (x % y) == 0 : false; "
" default : is_prime_impl2(x,y - 1); "
" } "
));
compositor.add(
function_t("is_prime2")
.var("x")
.expression
(
" switch "
" { "
" case x <= 0 : false; "
" case frac(x) != 0 : false; "
" default : is_prime_impl2(x,min(x - 1,trunc(sqrt(x)) + 1)); "
" } "
));
//Mode 3 - switch statement and for-loop based
compositor.add(
function_t("is_prime3")
.var("x")
.expression
(
" switch "
" { "
" case x <= 1 : return [false]; "
" case frac(x) != 0 : return [false]; "
" case x == 2 : return [true ]; "
" }; "
" "
" var prime_lut[27] := "
" { "
" 2, 3, 5, 7, 11, 13, 17, 19, 23, "
" 29, 31, 37, 41, 43, 47, 53, 59, 61, "
" 67, 71, 73, 79, 83, 89, 97, 101, 103 "
" }; "
" "
" var upper_bound := min(x - 1, trunc(sqrt(x)) + 1); "
" "
" for (var i := 0; i < prime_lut[]; i += 1) "
" { "
" if (prime_lut[i] >= upper_bound) "
" return [true]; "
" else if ((x % prime_lut[i]) == 0) "
" return [false]; "
" }; "
" "
" var lower_bound := prime_lut[prime_lut[] - 1] + 2; "
" "
" for (var i := lower_bound; i < upper_bound; i += 2) "
" { "
" if ((x % i) == 0) "
" { "
" return [false]; "
" } "
" }; "
" "
" return [true]; "
));
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 < 15000; ++i)
{
x = static_cast<T>(i);
const T result1 = expression1.value();
const T result2 = expression2.value();
const T result3 = expression3.value();
const bool results_concur = (result1 == result2) &&
(result1 == result3) ;
printf("%03d Result1: %c Result2: %c Result3: %c "
"Results Concur: %c\n",
static_cast<unsigned int>(i),
(result1 == T(1)) ? 'T' : 'F',
(result2 == T(1)) ? 'T' : 'F',
(result3 == T(1)) ? 'T' : 'F',
(results_concur) ? 'T' : 'F');
}
}
int main()
{
primes<double>();
return 0;
}

97
exprtk_simple_example_10.cpp
View File

@ -1,97 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 10 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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("newton_sqrt")
.var("x")
.expression
(
" 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); "
" }; "
" } "
));
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 < 1000; ++i)
{
x = static_cast<T>(i);
const T result = expression.value();
const T real = std::sqrt(x);
const T error = std::abs(result - real);
printf("sqrt(%03d) - Result: %15.13f\tReal: %15.13f\tError: %18.16f\n",
static_cast<unsigned int>(i),
result,
real,
error);
}
}
int main()
{
newton_sqrt<double>();
return 0;
}

74
exprtk_simple_example_11.cpp
View File

@ -1,74 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 11 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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;
}

69
exprtk_simple_example_12.cpp
View File

@ -1,69 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 12 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: MIT *
* *
**************************************************************
*/
#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[]; "
" "
" repeat "
" var new_upper_bound := 0; "
" "
" for (var i := 1; i < upper_bound; i += 1) "
" { "
" if (v[i - 1] > v[i]) "
" { "
" v[i - 1] <=> v[i]; "
" new_upper_bound := i; "
" }; "
" }; "
" "
" upper_bound := new_upper_bound; "
" "
" until (upper_bound <= 1); ";
T v[] = { T(9.1), T(2.2), T(1.3), T(5.4), T(7.5), T(4.6), T(3.7) };
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;
}

101
exprtk_simple_example_13.cpp
View File

@ -1,101 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 13 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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[]) "
" { "
" const var lower_bound := trunc(weight[] / 2); "
" const 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))
{
const 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;
}

57
exprtk_simple_example_14.cpp
View File

@ -1,57 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 14 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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;
}

95
exprtk_simple_example_15.cpp
View File

@ -1,95 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 15 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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 / k) + (r + v^2 / 2) * t) / (v * sqrt(t)); "
" var d2 := d1 - v * sqrt(t); "
" "
" if (callput_flag == 'call') "
" s * ncdf(d1) - k * e^(-r * t) * ncdf(d2); "
" else if (callput_flag == 'put') "
" k * e^(-r * t) * ncdf(-d2) - s * ncdf(-d1); "
" ";
T s = T(60.00); // Spot / Stock / Underlying / Base price
T k = T(65.00); // Strike price
T v = T( 0.30); // Volatility
T t = T( 0.25); // Years to maturity
T r = T( 0.08); // Risk free rate
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("k",k);
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";
const T bsm_call_option_price = expression.value();
callput_flag = "put";
const T bsm_put_option_price = expression.value();
printf("BSM(call, %5.3f, %5.3f, %5.3f, %5.3f, %5.3f) = %10.6f\n",
s, k, t, r, v,
bsm_call_option_price);
printf("BSM(put , %5.3f, %5.3f, %5.3f, %5.3f, %5.3f) = %10.6f\n",
s, k, t, r, v,
bsm_put_option_price);
const T put_call_parity_diff =
(bsm_call_option_price - bsm_put_option_price) -
(s - k * std::exp(-r * t));
printf("Put-Call parity difference: %20.17f\n", put_call_parity_diff);
}
int main()
{
black_scholes_merton_model<double>();
return 0;
}

83
exprtk_simple_example_16.cpp
View File

@ -1,83 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 16 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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;
}

79
exprtk_simple_example_17.cpp
View File

@ -1,79 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 17 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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 samples[2 * 10^8] := [(rnd_01^2 + rnd_01^2) <= 1]; "
" 4 * sum(samples) / samples[]; ";
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;
}

80
exprtk_simple_example_18.cpp
View File

@ -1,80 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 18 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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;
}

131
exprtk_simple_example_19.cpp
View File

@ -1,131 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 19 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: 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;
using namespace exprtk::rtl::vecops::helper;
if (
(1 == ps_index) &&
!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[noise[]] := 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;
}

109
exprtk_simple_example_20.cpp
View File

@ -1,109 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 20 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: MIT *
* *
**************************************************************
*/
#include <cstdio>
#include <stdexcept>
#include <map>
#include <string>
#include "exprtk.hpp"
struct vector_access_rtc : public exprtk::vector_access_runtime_check
{
typedef std::map<void*, std::string> map_t;
map_t vector_map;
bool handle_runtime_violation(violation_context& context)
{
const map_t::iterator itr = vector_map.find(static_cast<void*>(context.base_ptr));
std::string vector_name = (itr != vector_map.end()) ?
itr->second : "Unknown" ;
printf("Runtime vector access violation\n"
"Vector: %s base: %p end: %p access: %p typesize: %d\n",
vector_name.c_str(),
context.base_ptr ,
context.end_ptr ,
context.access_ptr ,
static_cast<unsigned int>(context.type_size));
throw std::runtime_error
("Runtime vector access violation. Vector: " + vector_name);
return false;
}
};
template <typename T>
void vector_overflow_example()
{
typedef exprtk::symbol_table<T> symbol_table_t;
typedef exprtk::expression<T> expression_t;
typedef exprtk::parser<T> parser_t;
const std::string expression_str =
" for (var i := 0; i < max(v0[],v1[]); i += 1) "
" { "
" v0[i] := (2 * v0[i]) + (v1[i] / 3); "
" } ";
T v0[5 ] = { 0, 1, 2, 3, 4 };
T v1[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
vector_access_rtc vec_rtc;
vec_rtc.vector_map[v0] = "v0";
vec_rtc.vector_map[v1] = "v1";
symbol_table_t symbol_table;
expression_t expression;
parser_t parser;
symbol_table.add_vector("v0", v0);
symbol_table.add_vector("v1", v1);
expression.register_symbol_table(symbol_table);
parser.register_vector_access_runtime_check(vec_rtc);
try
{
if (!parser.compile(expression_str, expression))
{
printf("Error: %s\tExpression: %s\n",
parser.error().c_str(),
expression_str.c_str());
return;
}
expression.value();
}
catch(std::runtime_error& exception)
{
printf("Exception: %s\n",exception.what());
}
}
int main()
{
vector_overflow_example<double>();
return 0;
}

117
exprtk_simple_example_21.cpp
View File

@ -1,117 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 21 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: MIT *
* *
**************************************************************
*/
#include <cstdio>
#include <string>
#include "exprtk.hpp"
template <typename T>
void binomial_option_pricing_model()
{
typedef exprtk::symbol_table<T> symbol_table_t;
typedef exprtk::expression<T> expression_t;
typedef exprtk::parser<T> parser_t;
const std::string european_option_binomial_model_program =
" var dt := t / n; "
" var z := exp(r * dt); "
" var z_inv := 1 / z; "
" var u := exp(v * sqrt(dt)); "
" var u_inv := 1 / u; "
" var p_up := (z - u_inv) / (u - u_inv); "
" var p_down := 1 - p_up; "
" "
" var option_price[n + 1] := [0]; "
" "
" for (var i := 0; i <= n; i += 1) "
" { "
" var base_price := s * u^(n - 2i); "
" option_price[i] := "
" switch "
" { "
" case callput_flag == 'call' : max(base_price - k, 0); "
" case callput_flag == 'put' : max(k - base_price, 0); "
" }; "
" }; "
" "
" for (var j := n - 1; j >= 0; j -= 1) "
" { "
" for (var i := 0; i <= j; i += 1) "
" { "
" option_price[i] := z_inv * "
" (p_up * option_price[i] + p_down * option_price[i + 1]); "
" } "
" }; "
" "
" option_price[0]; ";
T s = T( 100.00); // Spot / Stock / Underlying / Base price
T k = T( 110.00); // Strike price
T v = T( 0.30); // Volatility
T t = T( 2.22); // Years to maturity
T r = T( 0.05); // Risk free rate
T n = T(1000.00); // Number of time steps
std::string callput_flag;
symbol_table_t symbol_table;
symbol_table.add_variable("s",s);
symbol_table.add_variable("k",k);
symbol_table.add_variable("t",t);
symbol_table.add_variable("r",r);
symbol_table.add_variable("v",v);
symbol_table.add_constant("n",n);
symbol_table.add_stringvar("callput_flag",callput_flag);
expression_t expression;
expression.register_symbol_table(symbol_table);
parser_t parser;
parser.compile(european_option_binomial_model_program,expression);
callput_flag = "call";
const T binomial_call_option_price = expression.value();
callput_flag = "put";
const T binomial_put_option_price = expression.value();
printf("BinomialPrice(call, %5.3f, %5.3f, %5.3f, %5.3f, %5.3f) = %10.6f\n",
s, k, t, r, v,
binomial_call_option_price);
printf("BinomialPrice(put , %5.3f, %5.3f, %5.3f, %5.3f, %5.3f) = %10.6f\n",
s, k, t, r, v,
binomial_put_option_price);
const T put_call_parity_diff =
(binomial_call_option_price - binomial_put_option_price) -
(s - k * std::exp(-r * t));
printf("Put-Call parity difference: %20.17f\n", put_call_parity_diff);
}
int main()
{
binomial_option_pricing_model<double>();
return 0;
}

144
exprtk_simple_example_22.cpp
View File

@ -1,144 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 22 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: MIT *
* *
**************************************************************
*/
#include <cstdio>
#include <string>
#include "exprtk.hpp"
template <typename T>
void compute_implied_volatility()
{
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;
const std::string implied_volatility_program =
" const var epsilon := 0.0000001; "
" const var max_iters := 1000; "
" "
" var v := 0.5; /* Initial volatility guess */ "
" var itr := 0; "
" "
" while ((itr += 1) <= max_iters) "
" { "
" var price := "
" switch "
" { "
" case callput_flag == 'call' : bsm_call(s, k, r, t, v); "
" case callput_flag == 'put' : bsm_put (s, k, r, t, v); "
" }; "
" "
" var price_diff := price - target_price; "
" "
" if (abs(price_diff) <= epsilon) "
" { "
" break; "
" }; "
" "
" v -= price_diff / vega(s, k, r, t, v); "
" }; "
" "
" itr <= max_iters ? v : null; ";
T s = T( 100.00); // Spot / Stock / Underlying / Base price
T k = T( 110.00); // Strike price
T t = T( 2.22); // Years to maturity
T r = T( 0.05); // Risk free rate
T target_price = T( 0.00);
std::string callput_flag;
symbol_table_t symbol_table(symbol_table_t::e_immutable);
symbol_table.add_variable("s",s);
symbol_table.add_variable("k",k);
symbol_table.add_variable("t",t);
symbol_table.add_variable("r",r);
symbol_table.add_stringvar("callput_flag",callput_flag);
symbol_table.add_variable ("target_price",target_price);
symbol_table.add_pi();
compositor_t compositor(symbol_table);
compositor.add(
function_t("bsm_call")
.vars("s", "k", "r", "t", "v")
.expression
(
" var d1 := (log(s / k) + (r + v^2 / 2) * t) / (v * sqrt(t)); "
" var d2 := d1 - v * sqrt(t); "
" s * ncdf(d1) - k * exp(-r * t) * ncdf(d2); "
));
compositor.add(
function_t("bsm_put")
.vars("s", "k", "r", "t", "v")
.expression
(
" var d1 := (log(s / k) + (r + v^2 / 2) * t) / (v * sqrt(t)); "
" var d2 := d1 - v * sqrt(t); "
" k * exp(-r * t) * ncdf(-d2) - s * ncdf(-d1); "
));
compositor.add(
function_t("vega")
.vars("s", "k", "r", "t", "v")
.expression
(
" var d1 := (log(s / k) + (r + v^2 / 2) * t) / (v * sqrt(t)); "
" s * sqrt(t) * exp(-d1^2 / 2) / sqrt(2pi); "
));
expression_t expression;
expression.register_symbol_table(symbol_table);
parser_t parser;
parser.compile(implied_volatility_program,expression);
{
callput_flag = "call";
target_price = T(18.339502);
const T implied_vol = expression.value();
printf("Call Option(s: %5.3f, k: %5.3f, t: %5.3f, r: %5.3f) "
"@ $%8.6f Implied volatility = %10.8f\n",
s, k, t, r, target_price, implied_vol);
}
{
callput_flag = "put";
target_price = T(16.782764);
const T implied_vol = expression.value();
printf("Put Option(s: %5.3f, k: %5.3f, t: %5.3f, r: %5.3f) "
"@ $%8.6f Implied volatility = %10.8f\n",
s, k, t, r, target_price, implied_vol);
}
}
int main()
{
compute_implied_volatility<double>();
return 0;
}

136
exprtk_simple_example_23.cpp
View File

@ -1,136 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 23 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: MIT *
* *
**************************************************************
*/
#include <cstdio>
#include <string>
#include "exprtk.hpp"
template <typename T>
void real_1d_discrete_fourier_transform()
{
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;
const T sampling_rate = 1024.0; // ~1KHz
const T N = 8 * sampling_rate; // 8 seconds worth of samples
std::vector<T> input (static_cast<std::size_t>(N),0.0);
std::vector<T> output(static_cast<std::size_t>(N),0.0);
exprtk::rtl::io::println<T> println;
symbol_table_t symbol_table;
symbol_table.add_vector ("input" , input );
symbol_table.add_vector ("output" , output );
symbol_table.add_function ("println" , println );
symbol_table.add_constant ("N" , N );
symbol_table.add_constant ("sampling_rate", sampling_rate);
symbol_table.add_pi();
compositor_t compositor(symbol_table);
compositor.load_vectors(true);
compositor.add(
function_t("dft_1d_real")
.var("N")
.expression
(
" for (var k := 0; k < N; k += 1) "
" { "
" var k_real := 0.0; "
" var k_imag := 0.0; "
" "
" for (var i := 0; i < N; i += 1) "
" { "
" var theta := 2pi * k * i / N; "
" k_real += input[i] * cos(theta); "
" k_imag -= input[i] * sin(theta); "
" }; "
" "
" output[k] := hypot(k_real,k_imag); "
" } "
));
const std::string dft_program =
" "
" /* "
" Generate an aggregate waveform comprised of three "
" sine waves of varying frequencies and amplitudes. "
" */ "
" var frequencies[3] := { 100.0, 200.0, 300.0 }; /* Hz */ "
" var amplitudes [3] := { 10.0, 20.0, 30.0 }; /* Power */ "
" "
" for (var i := 0; i < N; i += 1) "
" { "
" var time := i / sampling_rate; "
" "
" for (var j := 0; j < frequencies[]; j += 1) "
" { "
" var frequency := frequencies[j]; "
" var amplitude := amplitudes [j]; "
" var theta := 2 * pi * frequency * time; "
" "
" input[i] += amplitude * sin(theta); "
" } "
" }; "
" "
" dft_1d_real(input[]); "
" "
" var freq_bin_size := sampling_rate / N; "
" var max_bin := ceil(N / 2); "
" var max_noise_level := 1e-5; "
" "
" /* Normalise amplitudes */ "
" output /= max_bin; "
" "
" println('1D Real DFT Frequencies'); "
" "
" for (var k := 0; k < max_bin; k += 1) "
" { "
" if (output[k] > max_noise_level) "
" { "
" var freq_begin := k * freq_bin_size; "
" var freq_end := freq_begin + freq_bin_size; "
" "
" println('Index: ', k,' ', "
" 'Freq. range: [', freq_begin, 'Hz, ', freq_end, 'Hz) ', "
" 'Amplitude: ', output[k]); "
" } "
" } "
" ";
expression_t expression;
expression.register_symbol_table(symbol_table);
parser_t parser;
parser.compile(dft_program,expression);
expression.value();
}
int main()
{
real_1d_discrete_fourier_transform<double>();
return 0;
}

143
exprtk_simple_example_24.cpp
View File

@ -1,143 +0,0 @@
/*
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 24 *
* Author: Arash Partow (1999-2024) *
* URL: https://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. *
* https://www.opensource.org/licenses/MIT *
* SPDX-License-Identifier: MIT *
* *
**************************************************************
*/
#include <cstdio>
#include <string>
#include "exprtk.hpp"
template <typename T, T Process(const unsigned char)>
struct char_process : public exprtk::igeneric_function<T>
{
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::string_view string_t;
using exprtk::igeneric_function<T>::operator();
char_process()
: exprtk::igeneric_function<T>("S")
{}
inline T operator()(parameter_list_t parameters)
{
const unsigned char c = string_t(parameters[0])[0];
return Process(c);
}
};
template <typename T>
T is_digit_func(const unsigned char c)
{
return (('0' <= c) && (c <= '9')) ? T(1) : T(0);
}
template <typename T>
T to_num_func(const unsigned char c)
{
return static_cast<T>(c - '0');
}
template <typename T>
void rpn_example()
{
typedef exprtk::symbol_table<T> symbol_table_t;
typedef exprtk::expression<T> expression_t;
typedef exprtk::parser<T> parser_t;
const std::string rpn_program =
" var stack[1000] := [0]; "
" var stack_size := 0; "
" "
" for (var i := 0; i < rpn_expression[]; i += 1) "
" { "
" var c := rpn_expression[i : i + 1]; "
" "
" if (c == ' ') "
" { "
" continue; "
" } "
" else if (is_digit(c)) "
" { "
" stack[stack_size] := to_num(c); "
" stack_size += 1; "
" } "
" else "
" { "
" var operator := c; "
" var operand1 := stack[stack_size - 2]; "
" var operand2 := stack[stack_size - 1]; "
" stack_size -= 2; "
" "
" switch "
" { "
" case operator == '+' : stack[stack_size] := operand1 + operand2; "
" case operator == '-' : stack[stack_size] := operand1 - operand2; "
" case operator == '*' : stack[stack_size] := operand1 * operand2; "
" case operator == '/' : stack[stack_size] := operand1 / operand2; "
" case operator == '^' : stack[stack_size] := operand1 ^ operand2; "
" }; "
" "
" stack_size += 1; "
" } "
" }; "
" "
" println(stack[0], ' = ', rpn_expression); "
" ";
std::string rpn_expression;
char_process<T,is_digit_func<T>> isdigit;
char_process<T,to_num_func<T>> tonum;
exprtk::rtl::io::println<T> println;
symbol_table_t symbol_table;
symbol_table.add_stringvar("rpn_expression", rpn_expression);
symbol_table.add_function ("println" , println );
symbol_table.add_function ("is_digit" , isdigit );
symbol_table.add_function ("to_num" , tonum );
expression_t expression;
expression.register_symbol_table(symbol_table);
parser_t parser;
parser.compile(rpn_program, expression);
const std::string rpn_expressions[] =
{
"2 3 8 / ^ 4 6 * + 3 9 / -", // 2 ^ (3 / 8) + 4 * 6 - 3 / 9
"1 2 / 6 5 2 - / * 7 +" , // (1 / 2) * (6 / (5 - 2)) + 7
"1 2 * 3 / 4 * 5 / 6 *" , // ((((1 * 2) / 3) * 4) / 5) * 6
"8 6 4 + * 2 /" // (8 * (6 + 4)) / 2
};
for (std::size_t i = 0; i < sizeof(rpn_expressions) / sizeof(std::string); ++i)
{
rpn_expression = rpn_expressions[i];
expression.value();
}
}
int main()
{
rpn_example<double>();
return 0;
}

12699
exprtk_test.cpp
View File

File diff suppressed because it is too large Load Diff

22
license.txt
View File

@ -1,22 +0,0 @@
MIT License
Copyright (c) 1999-2024 Arash Partow
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

6238
readme.txt
View File

File diff suppressed because it is too large Load Diff