use crate::math::distributions::{normal_cdf, normal_pdf};
use std::ops::{Add, Div, Mul, Neg, Sub};
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct Dual64 {
pub val: f64,
pub der: f64,
}
impl Dual64 {
#[inline]
pub const fn constant(val: f64) -> Self {
Self { val, der: 0.0 }
}
#[inline]
pub const fn variable(val: f64) -> Self {
Self { val, der: 1.0 }
}
#[inline]
pub const fn new(val: f64, der: f64) -> Self {
Self { val, der }
}
#[inline]
pub fn ln(self) -> Self {
Self {
val: self.val.ln(),
der: self.der / self.val,
}
}
#[inline]
pub fn exp(self) -> Self {
let e = self.val.exp();
Self {
val: e,
der: self.der * e,
}
}
#[inline]
pub fn sqrt(self) -> Self {
let s = self.val.sqrt();
Self {
val: s,
der: self.der / (2.0 * s),
}
}
#[inline]
pub fn powi(self, n: i32) -> Self {
Self {
val: self.val.powi(n),
der: (n as f64) * self.val.powi(n - 1) * self.der,
}
}
#[inline]
pub fn powf(self, n: f64) -> Self {
Self {
val: self.val.powf(n),
der: n * self.val.powf(n - 1.0) * self.der,
}
}
#[inline]
pub fn normal_cdf(self) -> Self {
Self {
val: normal_cdf(self.val),
der: normal_pdf(self.val) * self.der,
}
}
#[inline]
pub fn normal_pdf(self) -> Self {
let pdf = normal_pdf(self.val);
Self {
val: pdf,
der: -self.val * pdf * self.der,
}
}
}
impl From<f64> for Dual64 {
#[inline]
fn from(v: f64) -> Self {
Self::constant(v)
}
}
impl Add for Dual64 {
type Output = Self;
#[inline]
fn add(self, rhs: Self) -> Self::Output {
Self {
val: self.val + rhs.val,
der: self.der + rhs.der,
}
}
}
impl Add<f64> for Dual64 {
type Output = Self;
#[inline]
fn add(self, rhs: f64) -> Self::Output {
Self {
val: self.val + rhs,
der: self.der,
}
}
}
impl Sub for Dual64 {
type Output = Self;
#[inline]
fn sub(self, rhs: Self) -> Self::Output {
Self {
val: self.val - rhs.val,
der: self.der - rhs.der,
}
}
}
impl Sub<f64> for Dual64 {
type Output = Self;
#[inline]
fn sub(self, rhs: f64) -> Self::Output {
Self {
val: self.val - rhs,
der: self.der,
}
}
}
impl Mul for Dual64 {
type Output = Self;
#[inline]
fn mul(self, rhs: Self) -> Self::Output {
Self {
val: self.val * rhs.val,
der: self.der * rhs.val + self.val * rhs.der,
}
}
}
impl Mul<f64> for Dual64 {
type Output = Self;
#[inline]
fn mul(self, rhs: f64) -> Self::Output {
Self {
val: self.val * rhs,
der: self.der * rhs,
}
}
}
impl Div for Dual64 {
type Output = Self;
#[inline]
fn div(self, rhs: Self) -> Self::Output {
Self {
val: self.val / rhs.val,
der: (self.der * rhs.val - self.val * rhs.der) / (rhs.val * rhs.val),
}
}
}
impl Div<f64> for Dual64 {
type Output = Self;
#[inline]
fn div(self, rhs: f64) -> Self::Output {
Self {
val: self.val / rhs,
der: self.der / rhs,
}
}
}
impl Neg for Dual64 {
type Output = Self;
#[inline]
fn neg(self) -> Self::Output {
Self {
val: -self.val,
der: -self.der,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct HyperDual64 {
pub val: f64,
pub der1: f64,
pub der2: f64,
pub der12: f64,
}
impl HyperDual64 {
#[inline]
pub const fn constant(val: f64) -> Self {
Self {
val,
der1: 0.0,
der2: 0.0,
der12: 0.0,
}
}
#[inline]
pub const fn variable(val: f64) -> Self {
Self {
val,
der1: 1.0,
der2: 1.0,
der12: 0.0,
}
}
#[inline]
pub const fn new(val: f64, der1: f64, der2: f64, der12: f64) -> Self {
Self {
val,
der1,
der2,
der12,
}
}
#[inline]
pub fn ln(self) -> Self {
let inv_val = 1.0 / self.val;
Self {
val: self.val.ln(),
der1: self.der1 * inv_val,
der2: self.der2 * inv_val,
der12: (self.der12 * self.val - self.der1 * self.der2) * (inv_val * inv_val),
}
}
#[inline]
pub fn exp(self) -> Self {
let e = self.val.exp();
Self {
val: e,
der1: self.der1 * e,
der2: self.der2 * e,
der12: (self.der12 + self.der1 * self.der2) * e,
}
}
#[inline]
pub fn sqrt(self) -> Self {
let s = self.val.sqrt();
let inv_2s = 0.5 / s;
Self {
val: s,
der1: self.der1 * inv_2s,
der2: self.der2 * inv_2s,
der12: inv_2s * (self.der12 - self.der1 * self.der2 * inv_2s / s),
}
}
#[inline]
pub fn powi(self, n: i32) -> Self {
let nf = n as f64;
let v_nm1 = self.val.powi(n - 1);
let v_nm2 = self.val.powi(n - 2);
Self {
val: self.val.powi(n),
der1: nf * v_nm1 * self.der1,
der2: nf * v_nm1 * self.der2,
der12: nf * v_nm1 * self.der12 + nf * (nf - 1.0) * v_nm2 * self.der1 * self.der2,
}
}
#[inline]
pub fn normal_cdf(self) -> Self {
let pdf = normal_pdf(self.val);
Self {
val: normal_cdf(self.val),
der1: pdf * self.der1,
der2: pdf * self.der2,
der12: pdf * (self.der12 - self.val * self.der1 * self.der2),
}
}
}
impl From<f64> for HyperDual64 {
#[inline]
fn from(v: f64) -> Self {
Self::constant(v)
}
}
impl Add for HyperDual64 {
type Output = Self;
#[inline]
fn add(self, rhs: Self) -> Self::Output {
Self {
val: self.val + rhs.val,
der1: self.der1 + rhs.der1,
der2: self.der2 + rhs.der2,
der12: self.der12 + rhs.der12,
}
}
}
impl Add<f64> for HyperDual64 {
type Output = Self;
#[inline]
fn add(self, rhs: f64) -> Self::Output {
Self {
val: self.val + rhs,
der1: self.der1,
der2: self.der2,
der12: self.der12,
}
}
}
impl Sub for HyperDual64 {
type Output = Self;
#[inline]
fn sub(self, rhs: Self) -> Self::Output {
Self {
val: self.val - rhs.val,
der1: self.der1 - rhs.der1,
der2: self.der2 - rhs.der2,
der12: self.der12 - rhs.der12,
}
}
}
impl Sub<f64> for HyperDual64 {
type Output = Self;
#[inline]
fn sub(self, rhs: f64) -> Self::Output {
Self {
val: self.val - rhs,
der1: self.der1,
der2: self.der2,
der12: self.der12,
}
}
}
impl Mul for HyperDual64 {
type Output = Self;
#[inline]
fn mul(self, rhs: Self) -> Self::Output {
Self {
val: self.val * rhs.val,
der1: self.der1 * rhs.val + self.val * rhs.der1,
der2: self.der2 * rhs.val + self.val * rhs.der2,
der12: self.der12 * rhs.val
+ self.der1 * rhs.der2
+ self.der2 * rhs.der1
+ self.val * rhs.der12,
}
}
}
impl Mul<f64> for HyperDual64 {
type Output = Self;
#[inline]
fn mul(self, rhs: f64) -> Self::Output {
Self {
val: self.val * rhs,
der1: self.der1 * rhs,
der2: self.der2 * rhs,
der12: self.der12 * rhs,
}
}
}
impl Div for HyperDual64 {
type Output = Self;
#[inline]
fn div(self, rhs: Self) -> Self::Output {
let inv_v = 1.0 / rhs.val;
let inv_v2 = inv_v * inv_v;
let d1 = (self.der1 * rhs.val - self.val * rhs.der1) * inv_v2;
let d2 = (self.der2 * rhs.val - self.val * rhs.der2) * inv_v2;
let d12 = (self.der12 * rhs.val + self.der1 * rhs.der2
- d1 * rhs.der2 * rhs.val
- self.der2 * rhs.der1
- self.val * rhs.der12)
* inv_v2
- d1 * rhs.der2 * inv_v;
Self {
val: self.val * inv_v,
der1: d1,
der2: d2,
der12: d12,
}
}
}
impl Div<f64> for HyperDual64 {
type Output = Self;
#[inline]
fn div(self, rhs: f64) -> Self::Output {
let inv = 1.0 / rhs;
Self {
val: self.val * inv,
der1: self.der1 * inv,
der2: self.der2 * inv,
der12: self.der12 * inv,
}
}
}
impl Neg for HyperDual64 {
type Output = Self;
#[inline]
fn neg(self) -> Self::Output {
Self {
val: -self.val,
der1: -self.der1,
der2: -self.der2,
der12: -self.der12,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_dual_differentiation() {
let x_val = 2.5;
let x = Dual64::variable(x_val);
let y = (x * x) * x.ln();
let expected_val = x_val * x_val * x_val.ln();
let expected_der = 2.0 * x_val * x_val.ln() + x_val;
assert!((y.val - expected_val).abs() < 1e-12);
assert!((y.der - expected_der).abs() < 1e-12);
}
#[test]
fn test_hyperdual_second_derivative() {
let x_val = 1.2;
let x = HyperDual64::variable(x_val);
let y = (x * x).exp();
let exp_term = (x_val * x_val).exp();
let expected_der = 2.0 * x_val * exp_term;
let expected_der2 = (2.0 + 4.0 * x_val * x_val) * exp_term;
assert!((y.val - exp_term).abs() < 1e-12);
assert!((y.der1 - expected_der).abs() < 1e-12);
assert!((y.der12 - expected_der2).abs() < 1e-12);
}
}