Struct Jet 

pub(crate) struct Jet<const N: usize> {
    pub(crate) value: Complex,
    pub(crate) derivative: [Complex; N],
}

A complex value and its first derivatives with respect to N inputs.

Kernels that are generic in N serve forward evaluation and differentiation alike. With N = 0 the derivative array is empty, so a forward evaluation stores and computes no derivatives. Operations with a real or complex scalar skip the zero derivative terms of a constant jet. Adding or subtracting a scalar still gives the value a constant jet gives, signed zeros included: the sign of a zero imaginary part selects the side of a branch cut downstream. special::RadialJet differs: it holds the first two derivatives in one variable.

Fields

value: Complex

The function value.

derivative: [Complex; N]

The derivative with respect to each of the N inputs.

Implementations

impl<const N: usize> Jet<N>

pub(crate) fn constant(value: impl Into<Complex>) -> Self

A value that depends on no input: every derivative is zero.

pub(crate) fn variable(value: impl Into<Complex>, index: usize) -> Self

Input number index itself: derivative one in that direction, zero in the others. An index of N or more gives a constant.

pub(crate) fn chain(self, value: Complex, derivative: Complex) -> Self

The chain rule: the jet of f(self) from value = f(x) and derivative = f'(x) at x = self.value. Each derivative of self is multiplied by f'(x).

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

Integer power self^n.

pub(crate) fn exp(self) -> Self

Complex exponential.

pub(crate) fn sqrt(self) -> Self

Principal square root, with the branch of numerics::complex_sqrt.

pub(crate) fn norm(self) -> f64

The largest modulus of the value and the derivatives.

pub(crate) fn finite(self) -> bool

Whether the value and every derivative are finite.

pub(crate) fn is_zero(self) -> bool

Whether the value and every derivative are zero, without the moduli of norm.

impl Jet<3>

pub(crate) fn compose<const N: usize>(self, inner: [Jet<N>; 3]) -> Jet<N>

The chain rule through three intermediate variables: self holds f and its derivatives with respect to x_b, inner[b] holds x_b and its derivatives with respect to N inputs. Returns the value of f with the derivatives sum_b df/dx_b dx_b/dt_a, summed in the order b = 0, 1, 2.

Trait Implementations

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

type Output = Jet<N>

The resulting type after applying the + operator.

fn add(self, rhs: Complex) -> Self

Performs the + operation.

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

type Output = Jet<N>

The resulting type after applying the + operator.

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

Performs the + operation.

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>) -> Jet<N>

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

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: Self) -> Self

Performs the + operation.

impl<const N: usize, Rhs> AddAssign<Rhs> for Jet<N>

where Self: Add<Rhs, Output = Self>,

fn add_assign(&mut self, rhs: Rhs)

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> Default for Jet<N>

fn default() -> Self

Returns the “default value” for a type.

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

type Output = Jet<N>

The resulting type after applying the / operator.

fn div(self, rhs: Complex) -> Self

Performs the / operation.

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

type Output = Jet<N>

The resulting type after applying the / operator.

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

Performs the / operation.

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>) -> Jet<N>

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

Performs the / operation.

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

type Output = Jet<N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Jet<N>

The resulting type after applying the * operator.

fn mul(self, rhs: Complex) -> Self

Performs the * operation.

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

type Output = Jet<N>

The resulting type after applying the * operator.

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

Performs the * 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>) -> Jet<N>

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

Performs the * operation.

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

type Output = Jet<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const N: usize, Rhs> MulAssign<Rhs> for Jet<N>

where Self: Mul<Rhs, Output = Self>,

fn mul_assign(&mut self, rhs: Rhs)

Performs the *= operation.

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

type Output = Jet<N>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

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

type Output = Jet<N>

The resulting type after applying the - operator.

fn sub(self, rhs: Complex) -> Self

Performs the - operation.

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

type Output = Jet<N>

The resulting type after applying the - operator.

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

Performs the - operation.

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>) -> Jet<N>

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

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: Self) -> Self

Performs the - operation.

impl<const N: usize, Rhs> SubAssign<Rhs> for Jet<N>

where Self: Sub<Rhs, Output = Self>,

fn sub_assign(&mut self, rhs: Rhs)

Performs the -= operation.

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

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

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