Crate dace

source ·
Expand description

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§

  • Wrapped C DACECore unsafe functions.

Macros§

  • Create a DA object.
  • Create an AlgebraicVector or an AlgebraicMatrix.

Structs§

  • Class to handle matrices and their operations.
  • Generic vector class to handle vectors of algebraic types and their algebraic operations.
  • Basic DA class representing a single polynomial.
  • Interval composed of a lower and an upper bound (f64).

Constants§

  • Archimedes’ constant (π)

Traits§

  • Assignment of a value to an object.
  • Compilation of an object into a compiledDA object.
  • Cross product of two objects.
  • Matrix Multiplication
  • Evaluation of a DA object with another object.
  • Defines a multiplicative identity element for Self.
  • Binary operator for raising a value to a power.
  • Defines an additive identity element for Self.