Struct peroxide::structure::ad::ADFn

pub struct ADFn<F> { /* fields omitted */ }

Generic AD functions

Description

To lift AD functions

Implementation

• All Fn(AD) -> AD functions can be lift to Fn(f64) -> f64 via StableFn<f64>
• grad(&self) -> Self gives gradient of original function
• But still can use Fn(AD) -> AD via StableFn<AD>

Usage

extern crate peroxide;
use peroxide::fuga::*;

fn main() {
    let ad0 = 2f64;
    let ad1 = AD1(2f64, 1f64);
    let ad2 = AD2(2f64, 1f64, 0f64);

    let f_ad = ADFn::new(f);

    let ans0 = ad0.powi(2);
    let ans1 = ad1.powi(2).dx();
    let ans2 = ad2.powi(2).ddx();

    assert_eq!(ans0, f_ad.call_stable(ad0));

    let df = f_ad.grad();
    assert_eq!(ans1, df.call_stable(ad0));

    let ddf = df.grad();
    assert_eq!(ans2, ddf.call_stable(ad0));

    let ad1_output = f_ad.call_stable(ad1);
    assert_eq!(ad1_output, AD1(4f64, 4f64));

    let ad2_output = f_ad.call_stable(ad2);
    assert_eq!(ad2_output, AD2(4f64, 4f64, 2f64));
}

fn f(x: AD) -> AD {
    x.powi(2)
}

Implementations

impl<F: Clone> ADFn<F>

pub fn new(f: F) -> Self

pub fn grad(&self) -> Self

Gradient

Trait Implementations

impl<F: Fn(AD) -> AD> StableFn<AD> for ADFn<F>

type Output = AD

pub fn call_stable(&self, target: AD) -> Self::Output

impl<F: Fn(Vec<AD>) -> Vec<AD>> StableFn<Vec<AD, Global>> for ADFn<F>

type Output = Vec<AD>

pub fn call_stable(&self, target: Vec<AD>) -> Self::Output

impl<F: Fn(Vec<AD>) -> Vec<AD>> StableFn<Vec<f64, Global>> for ADFn<F>

type Output = Vec<f64>

pub fn call_stable(&self, target: Vec<f64>) -> Self::Output

impl<F: Fn(AD) -> AD> StableFn<f64> for ADFn<F>

type Output = f64

pub fn call_stable(&self, target: f64) -> Self::Output