Struct Application 

pub struct Application {

    pub prog: Program,
    pub compiled: Option<MachineCode<f64>>,
    pub compiled_simd: Option<MachineCode<f64>>,
    pub compiled_fast: Option<MachineCode<f64>>,
    pub bytecode: CompiledMir,
    pub params: Vec<f64>,
    pub use_simd: bool,
    pub use_threads: bool,
    pub can_fast: bool,
    pub first_state: usize,
    pub first_param: usize,
    pub first_obs: usize,
    pub first_diff: usize,
    pub count_states: usize,
    pub count_params: usize,
    pub count_obs: usize,
    pub count_diffs: usize,
}

Fields

prog: Program

compiled: Option<MachineCode<f64>>

compiled_simd: Option<MachineCode<f64>>

compiled_fast: Option<MachineCode<f64>>

bytecode: CompiledMir

params: Vec<f64>

use_simd: bool

use_threads: bool

can_fast: bool

first_state: usize

first_param: usize

first_obs: usize

first_diff: usize

count_states: usize

count_params: usize

count_obs: usize

count_diffs: usize

Implementations

impl Application

pub fn call(&mut self, args: &[f64]) -> Vec<f64>

Calls the compiled function.

args is a slice of f64 values, corresponding to the states.

The output is a Vec<f64>, corresponding to the observables (the expressions passed to compile).

pub fn call_params(&mut self, args: &[f64], params: &[f64]) -> Vec<f64>

Sets the params and calls the compiled function.

args is a slice of f64 values, corresponding to the states. params is a slice of f64 values, corresponding to the params.

The output is a Vec<f64>, corresponding to the observables (the expressions passed to compile).

pub fn evaluate<T>(&mut self, args: &[T], outs: &mut [T])

where T: Element,

Generic evaluate function for compiled Symbolica expressions

pub fn evaluate_single<T>(&mut self, args: &[T]) -> T

where T: Element + Copy,

Generic evaluate_single function for compiled Symbolica expressions

pub fn evaluate_matrix<T>(&mut self, args: &[T], outs: &mut [T], n: usize)

where T: Element,

Generic evaluate function for compiled Symbolica expressions The main entry point to compute matrices. The actual dispatched method depends on the configuration and the type of the arguments.

pub fn fast_func(&mut self) -> Result<FastFunc<'_>>

Returns a fast function.

Application call functions need to copy the input argument slice into the function memory area and then copy the output to a Vec. This process is acceptable for large and complex functions but incurs a penalty for small functions. Therefore, for a certain subset of applications, Symjit can compile a fast funcction and return a function pointer. Examples:

fn test_fast() -> Result<()> {
    let x = Expr::var("x");
    let y = Expr::var("y");
    let z = Expr::var("z");
    let u = &x * &(&y - &z).pow(&Expr::from(2));

    let mut comp = Compiler::new();
    let mut app = comp.compile(&[x, y, z], &[u])?;
    let f = app.fast_func()?;

    if let FastFunc::F3(f, _) = f {
        let res = f(3.0, 5.0, 9.0);
        println!("fast\t{:?}", &res);
    }

    Ok(())
}

The conditions for a fast function are:

• A fast function can have 1 to 8 arguments.
• No SIMD and no parameters.
• It returns only a single value.

If these conditions are met, you can generate a fast functin by calling app.fast_func(), with a return type of Result<FastFunc>. FastFunc is an enum with eight variants F1, F2, ..., F8`, corresponding to functions with 1 to 8 arguments.

impl Application

pub fn new( prog: Program, reals: HashSet<Loc>, df: Defuns, ) -> Result<Application>

pub fn seal(self) -> Result<Applet>

pub fn exec(&mut self)

pub fn exec_callable(&mut self, xx: &[f64]) -> f64

pub fn prepare_simd(&mut self)

pub fn get_fast( &mut self, ) -> Option<fn(*const f64, *const &mut [f64], usize, *const f64) -> i32>

pub fn exec_vectorized(&mut self, states: &mut Matrix<'_>, obs: &mut Matrix<'_>)

pub fn exec_vectorized_simple( &mut self, states: &Matrix<'_>, obs: &mut Matrix<'_>, )

pub fn exec_vectorized_scalar( &mut self, states: &mut Matrix<'_>, obs: &mut Matrix<'_>, threads: bool, )

pub fn exec_vectorized_simd( &mut self, states: &mut Matrix<'_>, obs: &mut Matrix<'_>, threads: bool, l: usize, )

pub fn dump(&mut self, name: &str, what: &str) -> bool

pub fn dumps(&self) -> Vec<u8>

Trait Implementations

impl Clone for Application

fn clone(&self) -> Application

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Storage for Application

fn save(&self, stream: &mut impl Write) -> Result<()>

fn load(stream: &mut impl Read) -> Result<Self>