Crate dace

Rust wrapper of DACE, the Differential Algebra Computational Toolbox.

Introduction

DACE-RS is a Rust wrapper of DACE, the Differential Algebra Computational Toolbox (https://github.com/dacelib/dace).

You can find further details on Differential Algebra and its applications on that web page.

Installation

DACE-RS can be used in your project by including it as a Cargo dependency.

Add this to your Cargo.toml:

[dependencies]
dace = "0.2"

If you need to use the AlgebraicVector<DA>::invert() function, you need to include ndarray-linalg and specify a LAPACK binding (see: https://github.com/rust-ndarray/ndarray-linalg).

Example:

[dependencies]
dace = "0.2"
ndarray-linalg = { version = "0.16", features = ["openblas-static"] }

This is needed also to run tests, e.g.: cargo test --features=ndarray-linalg/openblas-static

CMake and a C compiler must be installed in the system to build the DACE Core library.

Tutorials

The original DACE C++ tutorials have been translated to Rust and are available in the examples folder: https://github.com/giovannipurpura/dace-rs/tree/master/examples

Examples

This is a quick example for basic usage:

use dace::*; // import all DACE elements

fn main() {
    // initialize DACE with order 10 and 3 variables
    DA::init(10, 3);

    // assign the three variables to x, y, z -- notice that integers are used here!
    let (x, y, z): (DA, DA, DA) = (da!(1), da!(2), da!(3));
    // create also some constants as DA objects -- notice that floats are used here!
    let (a, b, c): (DA, DA, DA) = (da!(1.0), da!(2.0), da!(3.0));

    // compute a * sin(x) + b * cos(y) + c * tan(z)
    let v1: DA = &a * x.sin() + &b * y.cos() + &c * z.tan();
    // print the resulting DA variable
    println!("{v1}");

    // do the same without using the DA constants a, b, c
    let v2: DA = 1.0 * x.sin() + 2.0 * y.cos() + 3.0 * z.tan();
    // check that we got the same result
    println!("v1 == v2: {}", v1 == v2);

    // try also with AlgebraicVector<DA> and AlgebraicVector<f64>
    let xyz: AlgebraicVector<DA> = darray![x.sin(), y.cos(), z.tan()];
    let abc: AlgebraicVector<f64> = darray![1.0, 2.0, 3.0];
    let v3: DA = xyz.dot(&abc);
    // check that we got the same result
    println!("v1 == v3: {}", v1 == v3);

    // try also with AlgebraicMatrix<DA> and AlgebraicMatrix<f64>
    let xyz: AlgebraicMatrix<DA> = darray![[x.sin(), y.cos(), z.tan()]];
    let abc: AlgebraicMatrix<f64> = darray![[1.0], [2.0], [3.0]];
    let v4: AlgebraicMatrix<DA> = xyz.dot(&abc);
    // check that we got the same result
    println!("v1 == v4: {}", v1 == v4[(0, 0)]);
}

Modules

dacecore

Wrapped C DACECore unsafe functions.

Macros

da

Create a DA object.

darray

Create an AlgebraicVector or an AlgebraicMatrix.

Structs

AlgebraicMatrix

Class to handle matrices and their operations.

AlgebraicVector

Generic vector class to handle vectors of algebraic types and their algebraic operations.

DA

Basic DA class representing a single polynomial.

Interval

Interval composed of a lower and an upper bound (f64).

Constants

PI

Archimedes’ constant (π)

Traits

Assign

Assignment of a value to an object.

Compile

Compilation of an object into a compiledDA object.

Cross

Cross product of two objects.

Dot

Matrix Multiplication

Eval

Evaluation of a DA object with another object.

One

Defines a multiplicative identity element for Self.

Pow

Binary operator for raising a value to a power.

Zero

Defines an additive identity element for Self.