13 releases
0.5.3  Mar 17, 2024 

0.4.5rc.1  Jul 23, 2023 
0.4.4  Jan 8, 2023 
0.4.3  Dec 9, 2022 
0.3.1alpha.1  Aug 29, 2022 
#73 in Math
36KB
684 lines
Automatic Differentiation Library
AUTOmatic Derivatives & Jacobians by djmaxus and you
Functionality
Single variables
use autodj::prelude::single::*;
let x : DualF64 = 2.0.into_variable();
// Arithmetic operations are required by trait bounds
let _f = x * x + 1.0.into();
// Arithmetic rules itself are defined in `Dual` trait
// on borrowed values for extendability
let f = (x*x).add_impl(&1.0.into());
// Dual can be decomposed into a valuederivative pair
assert_eq!(f.decompose(), (5.0, 4.0));
// fmt::Display resembles Taylor expansion
assert_eq!(format!("{f}"), "5+4∆");
Multiple variables
Multivariate differentiation is based on multiple dual components. Such an approach requires no repetitive and "backward" differentiations. Each partial derivative is tracked separately from the start, and no repetitive calculations are made.
For builtin multivariate specializations,
independent variables can be created consistently using .into_variables()
method.
Static number of variables
use autodj::prelude::array::*;
// consistent set of independent variables
let [x, y] : [DualNumber<f64,2>; 2] = [2.0, 3.0].into_variables();
let f = x * (y  1.0.into());
assert_eq!(f.value() , & 4.);
assert_eq!(f.dual().as_ref(), &[2., 2.]);
assert_eq!(format!("{f}") , "4+[2.0, 2.0]∆");
Dynamic number of variables
use autodj::prelude::vector::*;
use std::ops::Add;
let x = vec![1., 2., 3., 4., 5.].into_variables();
let f : DualF64 = x.iter()
.map(x : &DualF64 x.mul_impl(&2.0.into()))
.reduce(Add::add)
.unwrap();
assert_eq!(f.value(), &30.);
f.dual()
.as_ref()
.iter()
.for_each(deriv assert_eq!(deriv, &2.0) );
Generic dual numbers
// A trait with all the behavior defined
use autodj::fluid::Dual;
// A generic data structure which implements Dual
use autodj::solid::DualNumber;
Motivation
I do both academic & business R&D in the area of computational mathematics. As well as many of us, I've written a whole bunch of sophisticated Jacobians by hand.
One day, I learned about automatic differentiation based on dual numbers. Almost the same day, I learned about Rust as well 🦀
Then, I decided to:
 Make it automatic and reliable as much as possible
 Use modern and convenient ecosystem of Rust development
Project goals
 Develop opensource automatic differentiation library for both academic and commercial computational mathematicians
 Gain experience of Rust programming
Anticipated features
You are very welcome to introduce issues to promote most wanted features or to report a bug.
 Generic implementation of dual numbers
 Number of variables to differentiate
 single
 multiple
 static
 dynamic
 sparse
 Jacobians (efficient layouts in memory to make matrices right away)
 Named variables (UUIDbased)
 Calculation tracking (partial derivatives of intermediate values)
 Thirdparty crates support (as features)

numtraits
 linear algebra crates (
nalgebra
etc.)


no_std
support  Advanced features
 Arbitrary number types beside
f64
 Interoperability of different dual types (e.g., single and multiple dynamic)
 Numerical verification (or replacement) of derivatives (by definition)
 Macro for automatic extensions of regular (i.e. nondual) functions
 Optional calculation of derivatives
 Backward differentiation probably
 Iterator implementation as possible approach to lazy evaluation
 Arbitrary number types beside
Comparison with autodiff
As far as I noticed, autodj
currently has the following differences
 Multiple variables out of the box
fmt::Display
for staticallyknown number of variables Lefttoright flow of many operations such as
.intovariables()
,.eval()
, etc.  Number type is restricted to
f64
 No utilization of
num
andnalgebra
crates
Some differences are planned to be eliminated as noted in the roadmap.
Within this crate, you may study & launch test target /tests/autodiff.rs
to follow some differences.
cargo test test autodiff  showoutput
Dependencies
~0.7–1MB
~17K SLoC