Struct SciPackage 

pub struct SciPackage(/* private fields */);

Package for scientific computing

Implementations

impl SciPackage

pub fn new() -> Self

Create a new SciPackage

Examples found in repository

examples/projectile_motion.rs (line 8)

fn main() {
    use rhai::{packages::Package, Engine};
    use rhai_sci::SciPackage;

    let mut engine = Engine::new();
    engine.register_global_module(SciPackage::new().as_shared_module());

    let result: rhai::Map = engine
        .eval_file("examples/projectile_motion.rhai".into())
        .expect("script should run");
    println!("{result:?}");
}

examples/neural_network_backprop.rs (line 10)

fn main() {
    #[cfg(feature = "nalgebra")]
    {
        use rhai::{packages::Package, Engine, Map};
        use rhai_sci::SciPackage;

        let mut engine = Engine::new();
        engine.register_global_module(SciPackage::new().as_shared_module());

        let result: Map = engine
            .eval_file("examples/neural_network_backprop.rhai".into())
            .expect("script should run");
        println!("{result:?}");
    }
}

examples/regression_workflow.rs (line 7)

fn main() -> Result<(), Box<rhai::EvalAltResult>> {
    use rhai::{packages::Package, Array, Engine, Scope};
    use rhai_sci::SciPackage;

    let mut engine = Engine::new();
    engine.register_global_module(SciPackage::new().as_shared_module());
    let observations = engine.eval::<Array>(r#"read_matrix("examples/data/calibration.csv")"#)?;
    let mut scope = Scope::new();
    scope.push("observations", observations);
    engine.run_with_scope(&mut scope, include_str!("regression_workflow.rhai"))
}

examples/matrix_inversion.rs (line 13)

fn main() {
    #[cfg(feature = "nalgebra")]
    {
        use rhai::{packages::Package, Engine};
        use rhai_sci::SciPackage;

        // Create a new Rhai engine
        let mut engine = Engine::new();

        // Add the rhai-sci package to the engine
        engine.register_global_module(SciPackage::new().as_shared_module());

        // Run the script that inverts a matrix
        let result = engine
            .run_file("examples/matrix_inversion.rhai".into())
            .expect("script should run");
        println!("{:?}", result);
    }
}

examples/download_and_regress.rs (line 11)

fn main() {
    #[cfg(all(feature = "nalgebra", feature = "io"))]
    {
        use rhai::{packages::Package, Engine};
        use rhai_sci::SciPackage;

        // Create a new Rhai engine
        let mut engine = Engine::new();

        // Add the rhai-sci package to the new engine
        engine.register_global_module(SciPackage::new().as_shared_module());

        // Now run your code
        let fitting_results = engine
            .run_file("examples/download_and_regress.rhai".into())
            .unwrap();
        println!("{:?}", fitting_results);
    }
}

Trait Implementations

impl Default for SciPackage

fn default() -> Self

Returns the “default value” for a type.

impl Package for SciPackage

fn as_shared_module(&self) -> Shared<Module>

Get a reference to a shared module from this package.

fn init(lib: &mut Module)

Initialize the package. Functions should be registered into module here.

fn init_engine(_engine: &mut Engine)

Initialize the package with an Engine.

fn register_into_engine(&self, engine: &mut Engine) -> &Self

Register the package with an Engine.

fn register_into_engine_as(&self, engine: &mut Engine, name: &str) -> &Self

Register the package with an Engine under a static namespace.