Expand description
§Aude
An automated differentiation solver with a Lisp-like functional programming language
=== Aude 0.2 ===
Type `help` for more information.
> mul
mul
ty: (fun (tup f64 f64) f64)
D: (lam (tup f64 f64) (tup mul($0) (lin_lam (tup f64 f64) add((tup mul((tup fst(f64)(f64)($0) fst(f64)(f64)($1))) mul((tup snd(f64)(f64)($0) snd(f64)(f64)($1))))))))To run Aude from your Terminal, type:
cargo install --example aude aude
Then, to run:
aude
§References
The Simple Essence of Automatic Differentiation
§Design
Aude uses a Lisp-like syntax, to avoid pain during translating to and from other programming languages.
For example, instead of f64 -> f64, Aude uses (ty f64 f64).
Function application uses the syntax <function>(<argument>),
e.g. sin(0).
Variables uses De Bruijn indices,
e.g. $0 refers to the lambda argument.
All operators take 2 arguments, e.g. (fun f64 f64).
§Features
| Function | Description |
|---|---|
| add | Addition |
| cos | Cosine (trigonometry) |
| fst | First tuple component |
| fst_par | First parallel component |
| id | Identity |
| neg | Negation |
| mul | Multiplication |
| sin | Sine (trigonometry) |
| snd | Second tuple component |
| snd_par | Second parallel component |
| Op | Description | Example |
|---|---|---|
| comp | Composes functions | g . f = (comp g f) |
| lin_comp | Composes linear functions | g . f = (lin_comp g f) |
| fun | Function type | f64 -> f64 = (fun f64 f64) |
| lin | Linear function type | f64 -o f64 = (lin f64 f64) |
| lam | Lambda expression | \x:f64.x = (lam f64 $0) |
| lam_lin | Linear lambda expression | \x:f64.x = (lin_lam f64 $0) |
| par | Parallel tuple | f x g = (par f g) |
| tup | Tuple | (f, g) = (tup f g) |
| ty | Type | x : f64 = (ty x f64) |
Modules§
- parsing
- Parsing.
Structs§
- F64Val
- Used to wrap f64 for
Expr.
Enums§
- Expr
- Represents an expression.
- Function
- Stores a function.
- Meta
- Stores meta data.
- Op
- Stores operator.
- Type
- Store a types.