Struct Jet 

pub struct Jet<const N: usize> { /* private fields */ }

Const-generic Taylor-mode forward AD type.

Stores the value and $N$ normalized Taylor coefficients:

• value = $f(a) = c_0$
• deriv[k] = $f^{(k+1)}(a) / (k+1)! = c_{k+1}$

So Jet<1> stores $(c_0, c_1) = (f(a),, f’(a))$, and Jet<2> stores $(c_0, c_1, c_2) = (f(a),, f’(a),, f’’(a)/2)$.

Implementations

impl<const N: usize> Jet<N>

pub fn new(value: f64, deriv: [f64; N]) -> Self

Create a Jet from raw value and normalized Taylor coefficient array.

pub fn var(x: f64) -> Self

Create an independent variable jet at point x. Sets deriv[0] = 1.0 (the 1st normalized coefficient), rest zero.

Examples

use peroxide::fuga::*;

let x = Jet::<2>::var(3.0);
assert_eq!(x.value(), 3.0);
assert_eq!(x.dx(), 1.0);    // dx/dx = 1
assert_eq!(x.ddx(), 0.0);   // d²x/dx² = 0

pub fn constant(x: f64) -> Self

Create a constant jet (all derivatives zero).

pub fn value(&self) -> f64

The function value $f(a)$.

pub fn x(&self) -> f64

Alias for value() — backward compatibility.

pub fn dx(&self) -> f64

First derivative $f’(a)$.

Examples

use peroxide::fuga::*;

let x = Jet::<1>::var(2.0);
let y = x.powi(3);    // x^3
assert_eq!(y.dx(), 12.0);  // 3*x^2 = 3*4 = 12

pub fn ddx(&self) -> f64

Second derivative $f’’(a)$.

Examples

use peroxide::fuga::*;

let x = Jet::<2>::var(2.0);
let y = x.powi(3);     // x^3
assert_eq!(y.ddx(), 12.0);  // 6*x = 6*2 = 12

pub fn derivative(&self, order: usize) -> f64

Returns $f^{(\mathrm{order})}(a)$, the raw (factorial-scaled) derivative of given order.

• order = 0: $f(a)$
• order = 1: $f’(a)$ = deriv[0]
• order = k: $f^{(k)}(a)$ = deriv[k-1] $\times, k!$

Internally computes taylor_coeff(k) $\times, k!$.

Examples

use peroxide::fuga::*;

let x = Jet::<3>::var(0.0);
let y = x.exp();
// All derivatives of exp at 0 are 1
assert!((y.derivative(0) - 1.0).abs() < 1e-15);
assert!((y.derivative(1) - 1.0).abs() < 1e-15);
assert!((y.derivative(2) - 1.0).abs() < 1e-15);
assert!((y.derivative(3) - 1.0).abs() < 1e-15);

pub fn taylor_coeff(&self, k: usize) -> f64

Returns the $k$-th normalized Taylor coefficient $c_k = f^{(k)}(a) / k!$.

• $k = 0$: $c_0 = f(a)$
• $k \ge 1$: $c_k$ = deriv[k-1]

impl<const N: usize> Jet<N>

pub fn sinh_cosh(&self) -> (Self, Self)

Compute $\sinh$ and $\cosh$ together via the coupled normalized recurrence.

Trait Implementations

impl<const N: usize> Add<Jet<N>> for f64

type Output = Jet<N>

The resulting type after applying the + operator.

fn add(self, rhs: Jet<N>) -> Self::Output

Performs the + operation.

impl<const N: usize> Add<f64> for Jet<N>

type Output = Jet<N>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<const N: usize> Add for Jet<N>

type Output = Jet<N>

The resulting type after applying the + operator.

fn add(self, rhs: Jet<N>) -> Self::Output

Performs the + operation.

impl<const N: usize> Clone for Jet<N>

fn clone(&self) -> Jet<N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize> Debug for Jet<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: usize> Display for Jet<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: usize> Div<Jet<N>> for f64

type Output = Jet<N>

The resulting type after applying the / operator.

fn div(self, rhs: Jet<N>) -> Self::Output

Performs the / operation.

impl<const N: usize> Div<f64> for Jet<N>

type Output = Jet<N>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<const N: usize> Div for Jet<N>

fn div(self, rhs: Jet<N>) -> Self::Output

Division using normalized Taylor coefficient recurrence: $z_0 = a_0 / b_0$, $z_n = \frac{1}{b_0}\left(a_n - \sum_{k=1}^{n} b_k , z_{n-k}\right)$

type Output = Jet<N>

The resulting type after applying the / operator.

impl<const N: usize> ExpLogOps for Jet<N>

fn exp(&self) -> Self

$\exp(a)$ using the normalized recurrence: $z_0 = e^{a_0}$, $z_n = \frac{1}{n}\sum_{k=1}^{n} k, a_k, z_{n-k}$

fn ln(&self) -> Self

$\ln(a)$ using the normalized recurrence: $z_0 = \ln(a_0)$, $z_n = \frac{1}{a_0}\left(a_n - \frac{1}{n}\sum_{k=1}^{n-1} k, z_k, a_{n-k}\right)$

type Float = f64

fn log(&self, base: f64) -> Self

fn log2(&self) -> Self

fn log10(&self) -> Self

impl<const N: usize> From<Jet<N>> for f64

fn from(j: Jet<N>) -> f64

Converts to this type from the input type.

impl<const N: usize> From<f64> for Jet<N>

fn from(v: f64) -> Self

Converts to this type from the input type.

impl<const N: usize> Index<usize> for Jet<N>

type Output = f64

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const N: usize> IndexMut<usize> for Jet<N>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<const N: usize> Mul<Jet<N>> for f64

type Output = Jet<N>

The resulting type after applying the * operator.

fn mul(self, rhs: Jet<N>) -> Self::Output

Performs the * operation.

impl<const N: usize> Mul<f64> for Jet<N>

type Output = Jet<N>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<const N: usize> Mul for Jet<N>

fn mul(self, rhs: Jet<N>) -> Self::Output

Multiplication using normalized Taylor coefficient convolution: $z_n = \sum_{k=0}^{n} c_k \cdot d_{n-k}$. No binomial coefficients needed due to normalization convention.

type Output = Jet<N>

The resulting type after applying the * operator.

impl<const N: usize> Neg for Jet<N>

type Output = Jet<N>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const N: usize> PartialEq for Jet<N>

fn eq(&self, other: &Jet<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> PartialOrd for Jet<N>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const N: usize> PowOps for Jet<N>

fn powi(&self, n: i32) -> Self

Integer power via repeated multiplication.

fn powf(&self, f: f64) -> Self

Float power: exp(f * ln(self))

fn pow(&self, rhs: Self) -> Self

Jet power: exp(rhs * ln(self))

fn sqrt(&self) -> Self

Square root using direct recurrence from $z^2 = a$: $z_0 = \sqrt{a_0}$, $z_n = \frac{1}{2,z_0}\left(a_n - \sum_{k=1}^{n-1} z_k, z_{n-k}\right)$

type Float = f64

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

Scalar version: F works with Jet<2>, target is Jet<2>.

type Output = Jet<2>

fn call_stable(&self, target: Jet<2>) -> Jet<2>

impl<const N: usize> Sub<Jet<N>> for f64

type Output = Jet<N>

The resulting type after applying the - operator.

fn sub(self, rhs: Jet<N>) -> Self::Output

Performs the - operation.

impl<const N: usize> Sub<f64> for Jet<N>

type Output = Jet<N>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<const N: usize> Sub for Jet<N>

type Output = Jet<N>

The resulting type after applying the - operator.

fn sub(self, rhs: Jet<N>) -> Self::Output

Performs the - operation.

impl<const N: usize> TrigOps for Jet<N>

fn sin_cos(&self) -> (Self, Self)

$\sin$ and $\cos$ computed together via coupled normalized recurrence: $s_0 = \sin(a_0)$, $c_0 = \cos(a_0)$, $s_n = \frac{1}{n}\sum_{k=1}^{n} k, a_k, c_{n-k}$, $c_n = -\frac{1}{n}\sum_{k=1}^{n} k, a_k, s_{n-k}$

fn sinh(&self) -> Self

$\sinh$ and $\cosh$ via coupled normalized recurrence (same as $\sin/\cos$ but no negative on $\cosh$): $s_n = \frac{1}{n}\sum_{k=1}^{n} k, a_k, c_{n-k}$, $c_n = \frac{1}{n}\sum_{k=1}^{n} k, a_k, s_{n-k}$

fn sin(&self) -> Self

fn cos(&self) -> Self

fn tan(&self) -> Self

fn cosh(&self) -> Self

fn tanh(&self) -> Self

fn asin(&self) -> Self

fn acos(&self) -> Self

fn atan(&self) -> Self

fn asinh(&self) -> Self

fn acosh(&self) -> Self

fn atanh(&self) -> Self

fn asin_acos(&self) -> (Self, Self)

fn asinh_acosh(&self) -> (Self, Self)

impl<const N: usize> Copy for Jet<N>

impl<const N: usize> StructuralPartialEq for Jet<N>