A single-header, dependency-free JIT compiler for mathematical expressions.

mexce is a runtime compiler for scalar mathematical expressions written in C++. It parses standard C-like expressions and compiles them directly into x86 or x86-64 machine code. On 64-bit systems, it uses SSE2 instructions for basic arithmetic and calls C standard library math functions for transcendentals. On 32-bit systems, or when higher internal precision is desired, the x87 FPU backend is used.

Once an expression is compiled, subsequent evaluations are direct function calls, which avoids parsing and interpretation overhead. This makes mexce well-suited for applications that repeatedly evaluate the same formula with different inputs, such as numerical simulations, data processing kernels, or graphics.

The library is contained in a single header file (mexce.h) with no external dependencies.

• Platforms: Windows, Linux
• Architectures: x86, x86-64 (SSE2 backend requires x86-64; x87 backend works on both)
• Compiler: Requires a C++11 compliant compiler.

Copy mexce.h into your project's include path and #include "mexce.h". No other steps are needed.

The following example shows how to bind variables and evaluate an expression in a loop. A mexce::evaluator instance initializes to the constant expression "0".

#include <iostream>
#include "mexce.h"
int main() {
    float   x  = 0.0f;
    double  y  = 0.1;
    mexce::evaluator eval;
    // Associate runtime variables with aliases in the expression.
    eval.bind(x, "x", y, "y");
    eval.set_expression("sin(x) + y");
    // The evaluator can also be used for single-shot evaluations
    // without changing the main expression.
    double result = eval.evaluate("x + y * y");
    std::cout << "Single-shot evaluation with x=0: " << result << std::endl;
    // Loop with the main expression
    std::cout << "\nLoop evaluation results:" << std::endl;
    for (int i = 0; i < 5; ++i, x += 0.1f) {
        std::cout << "  " << eval.evaluate() << std::endl;
    }
    return 0;
}

This program prints:

Single-shot evaluation with x=0: 0.01
Loop evaluation results:
  0.1
  0.199833
  0.298669
  0.39552
  0.489418

Associates a C++ variable with a symbolic name.

• Signature: void bind(T& var, const std::string& name, ...);
• Supported Types: double, float, int16_t, int32_t, int64_t.
• Behavior:
  • Bound variables must outlive the mexce::evaluator instance.
  • Throws std::logic_error if name collides with a built-in function or constant.

Removes one or all variable bindings.

• Signature: void unbind(const std::string& name, ...);, void unbind_all();
• Behavior:
  • If a variable used by the currently compiled expression is unbound, the expression is safely reset to the constant "0".
  • Throws std::logic_error if name is unknown or empty.

Compiles an expression, making it the default for evaluate().

• Signature: void set_expression(std::string expr);
• Behavior:
  • Throws mexce_parsing_exception on syntax errors, providing the position of the error.
  • Throws std::logic_error if the expression string is empty.

Executes the expression most recently compiled by set_expression().

• Signature: double evaluate();

Compiles and executes an expression for a single use without replacing the default expression.

• Signature: double evaluate(const std::string& expression);

Returns a mutable reference to the evaluator's options. Changes take effect on the next set_expression() call.

• Signature: options& opts();
• Example: eval.opts().fast_math = true;

Get or set the evaluator's options.

• Signatures: const options& get_options() const;, void set_options(const options& opts);

Options can be configured before calling set_expression() to control code generation behavior:

mexce::evaluator eval;
eval.enable_fast_math();           // Enable algebraic simplifications
eval.use_x87_backend();            // Use x87 FPU instead of SSE2
eval.enable_cse();                 // Enable common subexpression elimination
eval.set_expression("x + y");      // Options take effect here

mexce supports standard mathematical notation.

• Literals: Numbers in decimal (123.45) or scientific (1.2345e+02) notation.
• Operators: Infix operators with the following precedence:

  Precedence	Operator	Function	Description
  1 (highest)	^, **	pow	Power / Exponentiation
  2	*, /	mul, div	Multiplication, Division
  3	+, -	add, sub	Addition, Subtraction
  4 (lowest)	<, >	—	Less-than and greater-than comparison

• Unary Operators: Unary + and - are supported. Note that power operators (^ and **) bind tighter than unary minus, so -a**2 is evaluated as -(a**2), matching Python semantics. Use parentheses to change the grouping: (-a)**2.
• Comparison: The < and > operators return a double (1.0 if true, 0.0 if false).

• pi: The mathematical constant π.
• e: Euler's number e.

mexce provides two code generation backends:

• Uses SSE2 scalar instructions (addsd, mulsd, etc.) for basic arithmetic
• Uses SSE4.1 roundsd instruction for rounding functions (floor, ceil, round, trunc)
• Calls C standard library math functions for transcendentals (sin, cos, exp, log, etc.)
• Faster on modern CPUs due to better pipelining and avoiding x87 state transitions
• Results in XMM0 register (standard x64 ABI return convention)

• Uses x87 FPU instructions with 80-bit internal precision
• All operations (including transcendentals) use native x87 instructions
• Stack-based architecture can be more compact for certain expression patterns
• Required for Common Subexpression Elimination (CSE) feature
• On x86-64, enable with eval.use_x87_backend();

mexce is designed to produce code with performance comparable to a statically optimizing compiler. Its efficiency was measured using a benchmark suite of 44,229 expressions on GitHub Actions CI (Ubuntu runner).

Key observations:

• The SSE2 backend performs on par with or faster than native compiler-generated code
• The SSE2 backend is faster than the x87 backend due to better pipelining on modern CPUs
• The fast_math option provides modest improvement through algebraic simplification
• Compilation time is in the microsecond range, negligible for most use cases

Both backends produce results comparable to the native compiler. The table below shows accuracy measured in Units in the Last Place (ULP) against a high-precision reference computed with SymPy.

Notes:

• The x87 backend produces more exact results due to 80-bit internal precision
• Large ULP deviations occur in edge cases involving infinity or very large numbers
• Both backends match the native compiler's handling of special values

The benchmark harness is included in the repository and can be run using CMake:

# Configure and build the project
cmake -S . -B build
cmake --build build
# Run quick validation tests
ctest --test-dir build
# Run the full performance benchmark
cmake --build build --target run_benchmarks

The source code is licensed under the Simplified BSD License.