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

Compare commits

base: xfygogo:09c00211890b9ed4ab85f7745ff53514ed343bb9
Branches Tags
xfygogo:master
xfygogo:cmake
xfygogo:release
xfygogo:0.0.3-cmake
xfygogo:0.0.3
xfygogo:0.0.2-cmake
xfygogo:0.0.1-cmake
xfygogo:0.0.2
xfygogo:0.0.1
..
compare: xfygogo:c865f2d4c2752c170b2ba6e93b316cb67d9871c9
Branches Tags
xfygogo:cmake
xfygogo:master
xfygogo:release
xfygogo:0.0.3-cmake
xfygogo:0.0.3
xfygogo:0.0.2-cmake
xfygogo:0.0.1-cmake
xfygogo:0.0.2
xfygogo:0.0.1

1 Commits
09c0021189 ... c865f2d4c2

Author SHA1 Message Date
KatzirGal c865f2d4c2
Merge 6fc3a6d09a into f46bffcd69 2023-08-28 21:59:58 +03:00
33 changed files with 53882 additions and 65998 deletions
Show Stats Expand all files Collapse all files

71
.circleci/config.yml
View File

@ -19,33 +19,6 @@ jobs:
- 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
@ -59,44 +32,6 @@ 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
- build_gcc_09
- build_gcc_10
- build_gcc_latest

11
Makefile
View File

@ -2,15 +2,14 @@
# **************************************************************
# * C++ Mathematical Expression Toolkit Library *
# * *
# * Author: Arash Partow (1999-2024) *
# * Author: Arash Partow (1999-2023) *
# * 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 *
# * http://www.opensource.org/licenses/MIT *
# * *
# **************************************************************
#
@ -18,7 +17,7 @@
COMPILER := -c++
#COMPILER := -clang++
OPTIMIZATION_OPT := -O2 -DNDEBUG
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
@ -47,9 +46,9 @@ valgrind :
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)
$(COMPILER) $(BASE_OPTIONS) -O3 -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)
$(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

12930
exprtk.hpp
View File

File diff suppressed because it is too large Load Diff

93
exprtk_benchmark.cpp
View File

@ -3,7 +3,7 @@
* C++ Mathematical Expression Toolkit Library *
* *
* ExprTk vs Native Benchmarks *
* Author: Arash Partow (1999-2024) *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -19,6 +18,7 @@
#include <cstdio>
#include <cmath>
#include <iostream>
#include <fstream>
#include <string>
#include <deque>
@ -26,26 +26,26 @@
#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::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);
@ -323,7 +323,7 @@ int main(int argc, char* argv[])
}
{
printf("--- EXPRTK ---\n");
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]);
@ -331,28 +331,28 @@ int main(int argc, char* argv[])
}
{
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]);
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]);
}
{
printf("--- PARSE ----\n");
std::cout << "--- PARSE ----" << std::endl;
run_parse_benchmark(symbol_table);
}
@ -396,7 +396,7 @@ double pgo_primer()
return total;
}
inline std::size_t load_expression_file(const std::string& file_name, std::deque<std::string>& expression_list)
std::size_t load_expression_file(const std::string& file_name, std::deque<std::string>& expression_list)
{
std::ifstream stream(file_name.c_str());
@ -426,7 +426,7 @@ void perform_file_based_benchmark(const std::string& file_name, const std::size_
if (0 == load_expression_file(file_name,expr_str_list))
{
printf("Failed to load any expressions from: %s\n", file_name.c_str());
std::cout << "Failed to load any expressions from: " << file_name << "\n";
return;
}
@ -446,8 +446,6 @@ void perform_file_based_benchmark(const std::string& file_name, const std::size_
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);
@ -483,9 +481,6 @@ void perform_file_based_benchmark(const std::string& file_name, const std::size_
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);

75744
exprtk_functional_ext_test.txt
View File

File diff suppressed because it is too large Load Diff

15984
exprtk_functional_test.txt
View File

File diff suppressed because it is too large Load Diff

7
exprtk_simple_example_01.cpp
View File

@ -2,8 +2,8 @@
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 01 *
* Author: Arash Partow (1999-2024) *
* Simple Example 1 *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -31,7 +30,7 @@ void trig_function()
typedef exprtk::parser<T> parser_t;
const std::string expression_string =
"clamp(-1.0, sin(2 * pi * x) + cos(x / 2 * pi), +1.0)";
"clamp(-1.0,sin(2 * pi * x) + cos(x / 2 * pi),+1.0)";
T x;

25
exprtk_simple_example_02.cpp
View File

@ -2,8 +2,8 @@
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 02 *
* Author: Arash Partow (1999-2024) *
* Simple Example 2 *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -30,15 +29,15 @@ void square_wave()
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)) ";
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);
@ -56,7 +55,7 @@ void square_wave()
expression.register_symbol_table(symbol_table);
parser_t parser;
parser.compile(expression_string,expression);
parser.compile(expr_string,expression);
const T delta = (T(4) * pi) / T(1000);

7
exprtk_simple_example_03.cpp
View File

@ -2,8 +2,8 @@
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 03 *
* Author: Arash Partow (1999-2024) *
* Simple Example 3 *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -31,7 +30,7 @@ void polynomial()
typedef exprtk::parser<T> parser_t;
const std::string expression_string =
"25x^5 - 35x^4 - 15x^3 + 40x^2 - 15x + 1";
"25x^5 - 35x^4 - 15x^3 + 40x^2 - 15x + 1";
const T r0 = T(0);
const T r1 = T(1);

52
exprtk_simple_example_04.cpp
View File

@ -2,8 +2,8 @@
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 04 *
* Author: Arash Partow (1999-2024) *
* Simple Example 4 *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -32,32 +31,31 @@ void fibonacci()
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; "
" }; "
" }; "
" } "
));
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();

11
exprtk_simple_example_05.cpp
View File

@ -2,8 +2,8 @@
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 05 *
* Author: Arash Partow (1999-2024) *
* Simple Example 5 *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -32,14 +31,14 @@ struct myfunc : public exprtk::ifunction<T>
: exprtk::ifunction<T>(2)
{ exprtk::disable_has_side_effects(*this); }
T operator()(const T& v1, const T& v2)
inline 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)
inline T myotherfunc(T v0, T v1, T v2)
{
return std::abs(v0 - v1) * v2;
}
@ -52,7 +51,7 @@ void custom_function()
typedef exprtk::parser<T> parser_t;
const std::string expression_string =
"myfunc(sin(x / pi), otherfunc(3 * y, x / 2, x * y))";
"myfunc(sin(x / pi), otherfunc(3 * y, x / 2, x * y))";
T x = T(1);
T y = T(2);

13
exprtk_simple_example_06.cpp
View File

@ -2,8 +2,8 @@
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 06 *
* Author: Arash Partow (1999-2024) *
* Simple Example 6 *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -31,10 +30,10 @@ void vector_function()
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]); "
" } ";
" 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) };

5
exprtk_simple_example_07.cpp
View File

@ -2,8 +2,8 @@
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 07 *
* Author: Arash Partow (1999-2024) *
* Simple Example 7 *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/

27
exprtk_simple_example_08.cpp
View File

@ -2,8 +2,8 @@
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 08 *
* Author: Arash Partow (1999-2024) *
* Simple Example 8 *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -29,29 +28,27 @@ 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::parser_error::type error_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);
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("f","sin(x / pi)","x")); // f(x) = 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)]" ));
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)";
@ -68,7 +65,7 @@ void composite()
for (std::size_t i = 0; i < parser.error_count(); ++i)
{
const err_t error = parser.get_error(i);
const error_t error = parser.get_error(i);
printf("Error: %02d Position: %02d Type: [%14s] Msg: %s\tExpression: %s\n",
static_cast<unsigned int>(i),

174
exprtk_simple_example_09.cpp
View File

@ -2,8 +2,8 @@
**************************************************************
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 09 *
* Author: Arash Partow (1999-2024) *
* Simple Example 9 *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -42,98 +41,76 @@ void primes()
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( // 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("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)); "
));
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("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( // 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("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)); "
" } "
));
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 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]; "
));
//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)";
@ -148,11 +125,11 @@ void primes()
parser_t parser;
parser.compile(expression_str1, expression1);
parser.compile(expression_str2, expression2);
parser.compile(expression_str3, expression3);
parser.compile(expression_str1,expression1);
parser.compile(expression_str2,expression2);
parser.compile(expression_str3,expression3);
for (std::size_t i = 0; i < 15000; ++i)
for (std::size_t i = 0; i < 100; ++i)
{
x = static_cast<T>(i);
@ -160,16 +137,11 @@ void primes()
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",
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',
(results_concur) ? 'T' : 'F');
(result3 == T(1)) ? 'T' : 'F');
}
}

57
exprtk_simple_example_10.cpp
View File

@ -3,7 +3,7 @@
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 10 *
* Author: Arash Partow (1999-2024) *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -42,29 +41,28 @@ void newton_sqrt()
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); "
" }; "
" } "
));
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)";
@ -74,19 +72,16 @@ void newton_sqrt()
parser_t parser;
parser.compile(expression_str,expression);
for (std::size_t i = 0; i < 1000; ++i)
for (std::size_t i = 0; i < 100; ++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",
printf("sqrt(%03d) - Result: %15.13f\tReal: %15.13f\n",
static_cast<unsigned int>(i),
result,
real,
error);
std::sqrt(x));
}
}

17
exprtk_simple_example_11.cpp
View File

@ -3,7 +3,7 @@
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 11 *
* Author: Arash Partow (1999-2024) *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -31,14 +30,12 @@ void square_wave2()
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); ";
" 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);

40
exprtk_simple_example_12.cpp
View File

@ -3,7 +3,7 @@
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 12 *
* Author: Arash Partow (1999-2024) *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,12 +11,12 @@
* 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"
@ -30,25 +30,25 @@ void bubble_sort()
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); ";
" 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.1), T(2.2), T(1.3), T(5.4), T(7.5), T(4.6), T(3.7) };
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);

51
exprtk_simple_example_13.cpp
View File

@ -3,7 +3,7 @@
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 13 *
* Author: Arash Partow (1999-2024) *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -33,30 +32,30 @@ void savitzky_golay_filter()
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); "
" } ";
" 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;

21
exprtk_simple_example_14.cpp
View File

@ -3,7 +3,7 @@
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 14 *
* Author: Arash Partow (1999-2024) *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -30,15 +29,15 @@ void stddev_example()
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[]) ";
" 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;

59
exprtk_simple_example_15.cpp
View File

@ -3,7 +3,7 @@
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 15 *
* Author: Arash Partow (1999-2024) *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -31,20 +30,20 @@ void black_scholes_merton_model()
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); "
" ";
" 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); // Spot / Stock / Underlying / Base price
T k = T(65.00); // Strike price
T v = T( 0.30); // Volatility
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;
@ -52,7 +51,7 @@ void black_scholes_merton_model()
symbol_table_t symbol_table;
symbol_table.add_variable("s",s);
symbol_table.add_variable("k",k);
symbol_table.add_variable("x",x);
symbol_table.add_variable("t",t);
symbol_table.add_variable("r",r);
symbol_table.add_variable("v",v);
@ -65,27 +64,27 @@ void black_scholes_merton_model()
parser_t parser;
parser.compile(bsm_model_program,expression);
callput_flag = "call";
{
callput_flag = "call";
const T bsm_call_option_price = expression.value();
const T bsm = expression.value();
callput_flag = "put";
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);
}
const T bsm_put_option_price = expression.value();
{
callput_flag = "put";
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);
const T bsm = expression.value();
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);
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()

33
exprtk_simple_example_16.cpp
View File

@ -3,7 +3,7 @@
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 16 *
* Author: Arash Partow (1999-2024) *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -32,21 +31,21 @@ void linear_least_squares()
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; "
" } ";
" 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)};

7
exprtk_simple_example_17.cpp
View File

@ -3,7 +3,7 @@
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 17 *
* Author: Arash Partow (1999-2024) *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -49,8 +48,8 @@ void monte_carlo_pi()
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[]; ";
" var experiments[5 * 10^7] := [(rnd_01^2 + rnd_01^2) <= 1]; "
" 4 * sum(experiments) / experiments[]; ";
rnd_01<T> rnd01;

53
exprtk_simple_example_18.cpp
View File

@ -3,7 +3,7 @@
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 18 *
* Author: Arash Partow (1999-2024) *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -31,31 +30,31 @@ void file_io()
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]; "
" } ";
" 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;

52
exprtk_simple_example_19.cpp
View File

@ -3,7 +3,7 @@
* C++ Mathematical Expression Toolkit Library *
* *
* Simple Example 19 *
* Author: Arash Partow (1999-2024) *
* Author: Arash Partow (1999-2023) *
* URL: https://www.partow.net/programming/exprtk/index.html *
* *
* Copyright notice: *
@ -11,7 +11,6 @@
* 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 *
* *
**************************************************************
*/
@ -39,11 +38,11 @@ public:
randu()
: exprtk::igeneric_function<T>("V|VTT")
/*
Overloads:
0. V - vector
1. VTT - vector, r0, r1
*/
/*
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)
@ -53,11 +52,10 @@ public:
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)
!exprtk::rtl::vecops::helper::
load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0)
)
return T(0);
@ -87,23 +85,23 @@ void vector_randu()
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)); "
" ";
" 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) };

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;
}

11252
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.

2413
readme.txt
View File

File diff suppressed because it is too large Load Diff