Attribute Macro rust_ad::reverse_autodiff

#[reverse_autodiff]

Generates the reverse auto-differentiation function for a given function.

E.g.

#[rust_ad::reverse_autodiff]
fn function_name(x: f32, y: f32) -> f32 {
    let a = 7. * x;
    let b = 3. * x;
    let c = x + b;
    let d = y + b + c;
    return d;
}

Expands to:

fn __rev_function_name(x: f32, y: f32, der_d: f32) -> (f32, f32, f32) {
    let (x0, x1, x2) = (x.clone(), x.clone(), x.clone());
    let (y0,) = (y.clone(),);
    let a = 7. * x0;
    let b = 3. * x1;
    let (b0, b1) = (b.clone(), b.clone());
    let c = x2 + b0;
    let (c0,) = (c.clone(),);
    let _d = y0 + b1;
    let (_d0,) = (_d.clone(),);
    let d = _d0 + c0;
    let (der__d0, der_c0) = (d.clone(), d.clone());
    let der__d = der__d0;
    let (der_y0, der_b1) = (_d.clone(), _d.clone());
    let der_c = der_c0;
    let (der_x2, der_b0) = (c.clone(), c.clone());
    let der_b = der_b0 + der_b1;
    let der_x1 = 3. * b;
    let der_x0 = 7. * a;
    let der_y = der_y0;
    let der_x = der_x0 + der_x1 + der_x2;
    return (d, der_x, der_y);
}

Much like a derive macro, this is appended to your code, the original function_name function remains unedited.