Struct Compiler 

pub struct Compiler { /* private fields */ }

Implementations

impl Compiler

The central hub of the Rust interface. It compiles a list of variables and expressions into a callable object (of type Application).

Workflow

1. Create terminals (variables and constants) and compose expressions using Expr methods:
   • Constructors: var, from, unary, binary, …
   • Standard algebraic operations: add, mul, …
   • Standard operators +, -, *, /, %, &, |, ^, !.
   • Unary functions such as sin, exp, and other standard mathematical functions.
   • Binary functions such as pow, min, …
   • IfElse operation ifelse(cond, true_val, false_val).
   • Heavide function: heaviside(x), which returns 1 if x >= 0; otherwise 0.
   • Comparison methods eq, ne, lt, le, gt, and ge.
   • Looping constructs sum and prod.
2. Create a new Compiler object (say, comp) using one of its constructors: new() or with_compile_type(ty: CompilerType).
3. Fine-tune the optimization passes using opt_level, simd, fastmath, and cse methods (optional).
4. Define user-defined functions by called comp.def_unary and comp.def_binary (optional).
5. Compile by calling comp.compile or comp.compile_params. The result is of type Application (say, app).
6. Execute the compiled code using one of the app’s call functions:
   • call(&[f64]): scalar call.
   • call_params(&[f64], &[f64]): scalar call with parameters.
   • call_simd(&[__m256d]): simd call.
   • call_simd_params(&[__m256d], &[f64]): simd call with parameters.
7. Optionally, generate a standalone fast function to execute.

Examples

use anyhow::Result;
use symjit::{Compiler, Expr};

pub fn main() -> Result<()> {
    let x = Expr::var("x");
    let y = Expr::var("y");
    let u = &x + &y;
    let v = &x * &y;

    let mut config = Config::default();
    config.set_opt_level(2);
    let mut comp = Compiler::with_config(config);
    let mut app = comp.compile(&[x, y], &[u, v])?;
    let res = app.call(&[3.0, 5.0]);
    println!("{:?}", &res);

    Ok(())
}

pub fn new() -> Compiler

Creates a new Compiler object with default settings.

pub fn with_config(config: Config) -> Compiler

pub fn compile(&mut self, states: &[Expr], obs: &[Expr]) -> Result<Application>

Compiles a model.

states is a list of variables, created by Expr::var. obs is a list of expressions.

pub fn compile_params( &mut self, states: &[Expr], obs: &[Expr], params: &[Expr], ) -> Result<Application>

Compiles a model with parameters.

states is a list of variables, created by Expr::var. obs is a list of expressions. params is a list of parameters, created by Expr::var.

Note: for scalar functions, the difference between states and params is mostly by convenion. However, they are different in SIMD cases, as params are always f64.

impl Compiler

pub fn translate( &mut self, json: String, num_params: usize, ) -> Result<Application>

Compiles a Symbolica model.

json is the JSON-encoded output of Symbolica export_instructions.

Example:

let params = vec![parse!("x"), parse!("y")];
let eval = parse!("x + y^2")
    .evaluator(&FunctionMap::new(), &params, OptimizationSettings::default())?

let json = serde_json::to_string(&eval.export_instructions())?;
let mut comp = Compiler::new();
let mut app = comp.translate(&json)?;
assert!(app.evaluate_single(&[2.0, 3.0]) == 11.0);