tabulon 0.1.10

A high-performance, JIT-compiled expression evaluation engine using Cranelift
Documentation 
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

use tabulon::Tabula;

#[repr(C)]
struct Ctx { bias: f64 }

// Context-using unary function: returns x + ctx.bias
extern "C" fn add_bias(ctx: *mut std::ffi::c_void, x: f64) -> f64 {
    if ctx.is_null() { return f64::NAN; }
    let c = unsafe { &*(ctx as *const Ctx) };
    x + c.bias
}

// Context-using binary function: scales and adds with bias held in ctx
extern "C" fn scale_add(ctx: *mut std::ffi::c_void, a: f64, b: f64) -> f64 {
    if ctx.is_null() { return f64::NAN; }
    let c = unsafe { &*(ctx as *const Ctx) };
    a * c.bias + b
}

#[test]
fn unary_ctx_function_eval_with_ctx_ptr() {
    let mut eng = Tabula::<Ctx>::new_ctx();
    eng.register_unary("add_bias", add_bias, true).unwrap();

    let expr = eng.compile_ref("add_bias(A)").unwrap();
    let a = 5.0;

    let mut ctx = Ctx { bias: 10.0 };
    let out = expr.eval_with_ctx(&[&a], &mut ctx).unwrap();
    assert_eq!(out, 15.0);
}

#[test]
fn binary_ctx_function_eval_with_ctx() {
    let mut eng = Tabula::<Ctx>::new_ctx();
    eng.register_binary("scale_add", scale_add, true).unwrap();

    // expression: scale_add(x, y) with bias=2.0 => 3 * 2 + 4 = 10
    let expr = eng.compile_ref("scale_add(X, Y)").unwrap();
    let x = 3.0;
    let y = 4.0;

    let mut ctx = Ctx { bias: 2.0 };
    let out = expr.eval_with_ctx(&[&x, &y], &mut ctx).unwrap();
    assert_eq!(out, 10.0);
}