-
Notifications
You must be signed in to change notification settings - Fork 0
/
README.txt
75 lines (59 loc) · 3.58 KB
/
README.txt
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
FLEP - Fast Lite Expression Parser
Copyright (C) 2019 Gustavo Hime
In addition to the code of interest itself, i.e. flep.h and flep.c, you should have downloaded or otherwise obtained the following files:
README.txt - This text
README.md - Same text formatted for Github.
LICENSE - The Gnu Public Licence, version 3
example.c - A comprehensive example and test.
makefile - Builds the example program
expressions.txt - Sample input file for example program.
Otherwise, please download the full/latest version from the link below:
https://github.com/gustavohime/flep
***********
Description:
***********
FLEP compiles a parenthesized mathematical expression stored in a string and
then uses the compiled representation to evaluate it several times.
Expressions can contain:
- up to seven variables, designated by the letters "abcxyzw"
- standard operations +, -, /, * plus ^ for power
- balanced parentheses
- functions "sin", "cos", "tan", "log", "exp" and "sqrt"
- constants "e" and "pi"
FLEP uses a recursive parser to generate a RPN representation, then
runs it on a stack-based engine. FLEP's code is:
- Just plain old ANSI C.
- Uses plain old standard C libraries only.
- Is less than 600 LOC, less than 400 LOC if comments and blanks are removed.
- Compiles into an object with less than 12K with GCC.
- Is threadsafe.
There are several other C/C++ libraries you might want to check out. The [C++ Mathematical Expression Parser Benchmark](https://github.com/ArashPartow/math-parser-benchmark-project]) provides a quite thorough comparison, and depending on your priorities and constraints there might be more suitable alternatives. At the time of this writing, FLEP passes the benchmark suite with flying colors for correctness and speed, given its minimalistic approach: other packages provide faster evaluation at the cost of greatly increased complexity.
FLEP provides you with a GPLv3 absolute minimal implementation in C. Integrating it into your project should take no time, it should cause no conflicts and be as bug free as can be. I wrote it for fun and exercise: have fun using it without a care and do report any bugs you find, so I can bite my tongue and fix them.
**********
How to use:
**********
Here is the ABSOLUTE MINIMAL example of how to use it.
const char* exp = "a + b^(c/pi)" // expression to compile
const struct FLEP* f = flep_parse(exp); // compile, returns opaque structure
double abc[3] = {1.0, 2.0, 3.0}; // a = 1, b = 2, c = 3
double x = flep_eval(f, abc); // computes 'exp' for the values in 'abc'
flep_free(f); // release memory allocated by flep_parse
The preceding example does not account for parsing errors.
Malformed expressions may fail to parse, or there may be as-of-yet unknown
bugs. The following example is the PROPER USAGE, including error checking.
const char* exp = "a + b^(c/pi)"
int error, int position;
const struct FLEP* f = flep_parse(exp, &error, &position);
if (!f) { // failed to parse
printf("Failed to parse at position %d (%s)\n",
position, flep_translate(error));
exit(1); // deal with failure somehow
}
double abc[3] = {1.0, 2.0, 3.0};
double x = flep_eval(f, abc);
flep_free(f);
*********************************
Compiling and running the example:
*********************************
The compilation is rather trivial, you need 'gcc' and 'make. Just run 'make'.
You can then run 'example' without any arguments for a simplistic benchmark. Alternatively, you can run 'example [input.file]' to parse a list of expressions of your choice. A sample input file is provided - containing the same expressions hardcoded in example.c.