xad-rs 0.8.1

//! `Jet1` — active real for single-variable forward-mode AD.
//!
//! An [`Jet1<T>`] carries both a value and a single scalar tangent
//! (the derivative with respect to one seeded input direction).
//! Propagation uses the chain rule applied pointwise at every operator;
//! there is no tape, no thread-local state, and the type is entirely
//! stack-allocated and `Copy`-able modulo the inner scalar's `Clone`.
//!
//! Forward single-variable mode is the cheapest AD mode in this crate —
//! operators compile to a handful of fmul/fadds — so it's the right
//! choice when you have **one input direction** (seed `derivative = 1`
//! on exactly one variable) and you don't need the multi-direction
//! batching that [`Jet1Vec`](crate::jet1vec::Jet1Vec) provides.
//!
//! ```
//! use xad_rs::Jet1;
//!
//! // f(x) = x² + 3x, at x = 2
//! // f'(x) = 2x + 3 = 7
//! let x = Jet1::new(2.0_f64, 1.0);   // value 2, tangent 1
//! let f = &x * &x + &x * 3.0;
//! assert_eq!(f.value(), 10.0);
//! assert_eq!(f.derivative(), 7.0);
//! ```
//!
//! For **many** directions in a single forward pass, use
//! [`Jet1Vec`](crate::jet1vec::Jet1Vec) instead. For reverse mode, use
//! [`AReal`](crate::areal::AReal).

use crate::passive::Passive;
use std::fmt;
use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};

/// Active real number for forward-mode AD.
///
/// Stores a value and its tangent (derivative with respect to a seed direction).
#[derive(Clone)]
pub struct Jet1<T: Passive> {
    value: T,
    derivative: T,
}

impl<T: Passive> Jet1<T> {
    /// Create a new Jet1 with the given value and derivative.
    pub fn new(value: T, derivative: T) -> Self {
        Jet1 { value, derivative }
    }

    /// Create an Jet1 with zero derivative (a constant).
    pub fn constant(value: T) -> Self {
        Jet1 {
            value,
            derivative: T::zero(),
        }
    }

    /// Get the underlying value.
    #[inline]
    pub fn value(&self) -> T {
        self.value
    }

    /// Set the underlying value.
    #[inline]
    pub fn set_value(&mut self, v: T) {
        self.value = v;
    }

    /// Get the derivative (tangent).
    #[inline]
    pub fn derivative(&self) -> T {
        self.derivative
    }

    /// Set the derivative (tangent).
    #[inline]
    pub fn set_derivative(&mut self, d: T) {
        self.derivative = d;
    }
}

impl<T: Passive> From<T> for Jet1<T> {
    fn from(value: T) -> Self {
        Jet1::constant(value)
    }
}

impl From<i32> for Jet1<f64> {
    fn from(value: i32) -> Self {
        Jet1::constant(value as f64)
    }
}

impl From<i32> for Jet1<f32> {
    fn from(value: i32) -> Self {
        Jet1::constant(value as f32)
    }
}

// Jet1 + Jet1
impl<T: Passive> Add for Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn add(self, rhs: Jet1<T>) -> Jet1<T> {
        Jet1 {
            value: self.value + rhs.value,
            derivative: self.derivative + rhs.derivative,
        }
    }
}

impl<T: Passive> Add for &Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn add(self, rhs: &Jet1<T>) -> Jet1<T> {
        Jet1 {
            value: self.value + rhs.value,
            derivative: self.derivative + rhs.derivative,
        }
    }
}

impl<T: Passive> Add<&Jet1<T>> for Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn add(self, rhs: &Jet1<T>) -> Jet1<T> {
        Jet1 {
            value: self.value + rhs.value,
            derivative: self.derivative + rhs.derivative,
        }
    }
}

impl<T: Passive> Add<Jet1<T>> for &Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn add(self, rhs: Jet1<T>) -> Jet1<T> {
        Jet1 {
            value: self.value + rhs.value,
            derivative: self.derivative + rhs.derivative,
        }
    }
}

// Jet1 + scalar
impl<T: Passive> Add<T> for Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn add(self, rhs: T) -> Jet1<T> {
        Jet1 {
            value: self.value + rhs,
            derivative: self.derivative,
        }
    }
}

impl<T: Passive> Add<T> for &Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn add(self, rhs: T) -> Jet1<T> {
        Jet1 {
            value: self.value + rhs,
            derivative: self.derivative,
        }
    }
}

// scalar + Jet1
impl Add<Jet1<f64>> for f64 {
    type Output = Jet1<f64>;
    #[inline]
    fn add(self, rhs: Jet1<f64>) -> Jet1<f64> {
        Jet1 {
            value: self + rhs.value,
            derivative: rhs.derivative,
        }
    }
}

impl Add<&Jet1<f64>> for f64 {
    type Output = Jet1<f64>;
    #[inline]
    fn add(self, rhs: &Jet1<f64>) -> Jet1<f64> {
        Jet1 {
            value: self + rhs.value,
            derivative: rhs.derivative,
        }
    }
}

impl Add<Jet1<f32>> for f32 {
    type Output = Jet1<f32>;
    #[inline]
    fn add(self, rhs: Jet1<f32>) -> Jet1<f32> {
        Jet1 {
            value: self + rhs.value,
            derivative: rhs.derivative,
        }
    }
}

impl Add<&Jet1<f32>> for f32 {
    type Output = Jet1<f32>;
    #[inline]
    fn add(self, rhs: &Jet1<f32>) -> Jet1<f32> {
        Jet1 {
            value: self + rhs.value,
            derivative: rhs.derivative,
        }
    }
}

// Jet1 - Jet1
impl<T: Passive> Sub for Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn sub(self, rhs: Jet1<T>) -> Jet1<T> {
        Jet1 {
            value: self.value - rhs.value,
            derivative: self.derivative - rhs.derivative,
        }
    }
}

impl<T: Passive> Sub for &Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn sub(self, rhs: &Jet1<T>) -> Jet1<T> {
        Jet1 {
            value: self.value - rhs.value,
            derivative: self.derivative - rhs.derivative,
        }
    }
}

impl<T: Passive> Sub<&Jet1<T>> for Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn sub(self, rhs: &Jet1<T>) -> Jet1<T> {
        Jet1 {
            value: self.value - rhs.value,
            derivative: self.derivative - rhs.derivative,
        }
    }
}

impl<T: Passive> Sub<Jet1<T>> for &Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn sub(self, rhs: Jet1<T>) -> Jet1<T> {
        Jet1 {
            value: self.value - rhs.value,
            derivative: self.derivative - rhs.derivative,
        }
    }
}

// Jet1 - scalar
impl<T: Passive> Sub<T> for Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn sub(self, rhs: T) -> Jet1<T> {
        Jet1 {
            value: self.value - rhs,
            derivative: self.derivative,
        }
    }
}

impl<T: Passive> Sub<T> for &Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn sub(self, rhs: T) -> Jet1<T> {
        Jet1 {
            value: self.value - rhs,
            derivative: self.derivative,
        }
    }
}

// scalar - Jet1
impl Sub<Jet1<f64>> for f64 {
    type Output = Jet1<f64>;
    #[inline]
    fn sub(self, rhs: Jet1<f64>) -> Jet1<f64> {
        Jet1 {
            value: self - rhs.value,
            derivative: -rhs.derivative,
        }
    }
}

impl Sub<&Jet1<f64>> for f64 {
    type Output = Jet1<f64>;
    #[inline]
    fn sub(self, rhs: &Jet1<f64>) -> Jet1<f64> {
        Jet1 {
            value: self - rhs.value,
            derivative: -rhs.derivative,
        }
    }
}

impl Sub<Jet1<f32>> for f32 {
    type Output = Jet1<f32>;
    #[inline]
    fn sub(self, rhs: Jet1<f32>) -> Jet1<f32> {
        Jet1 {
            value: self - rhs.value,
            derivative: -rhs.derivative,
        }
    }
}

impl Sub<&Jet1<f32>> for f32 {
    type Output = Jet1<f32>;
    #[inline]
    fn sub(self, rhs: &Jet1<f32>) -> Jet1<f32> {
        Jet1 {
            value: self - rhs.value,
            derivative: -rhs.derivative,
        }
    }
}

// Jet1 * Jet1
impl<T: Passive> Mul for Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn mul(self, rhs: Jet1<T>) -> Jet1<T> {
        // d(a*b) = a'*b + a*b'
        Jet1 {
            value: self.value * rhs.value,
            derivative: self.derivative * rhs.value + self.value * rhs.derivative,
        }
    }
}

impl<T: Passive> Mul for &Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn mul(self, rhs: &Jet1<T>) -> Jet1<T> {
        Jet1 {
            value: self.value * rhs.value,
            derivative: self.derivative * rhs.value + self.value * rhs.derivative,
        }
    }
}

impl<T: Passive> Mul<&Jet1<T>> for Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn mul(self, rhs: &Jet1<T>) -> Jet1<T> {
        Jet1 {
            value: self.value * rhs.value,
            derivative: self.derivative * rhs.value + self.value * rhs.derivative,
        }
    }
}

impl<T: Passive> Mul<Jet1<T>> for &Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn mul(self, rhs: Jet1<T>) -> Jet1<T> {
        Jet1 {
            value: self.value * rhs.value,
            derivative: self.derivative * rhs.value + self.value * rhs.derivative,
        }
    }
}

// Jet1 * scalar
impl<T: Passive> Mul<T> for Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn mul(self, rhs: T) -> Jet1<T> {
        Jet1 {
            value: self.value * rhs,
            derivative: self.derivative * rhs,
        }
    }
}

impl<T: Passive> Mul<T> for &Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn mul(self, rhs: T) -> Jet1<T> {
        Jet1 {
            value: self.value * rhs,
            derivative: self.derivative * rhs,
        }
    }
}

// scalar * Jet1
impl Mul<Jet1<f64>> for f64 {
    type Output = Jet1<f64>;
    #[inline]
    fn mul(self, rhs: Jet1<f64>) -> Jet1<f64> {
        Jet1 {
            value: self * rhs.value,
            derivative: self * rhs.derivative,
        }
    }
}

impl Mul<&Jet1<f64>> for f64 {
    type Output = Jet1<f64>;
    #[inline]
    fn mul(self, rhs: &Jet1<f64>) -> Jet1<f64> {
        Jet1 {
            value: self * rhs.value,
            derivative: self * rhs.derivative,
        }
    }
}

impl Mul<Jet1<f32>> for f32 {
    type Output = Jet1<f32>;
    #[inline]
    fn mul(self, rhs: Jet1<f32>) -> Jet1<f32> {
        Jet1 {
            value: self * rhs.value,
            derivative: self * rhs.derivative,
        }
    }
}

impl Mul<&Jet1<f32>> for f32 {
    type Output = Jet1<f32>;
    #[inline]
    fn mul(self, rhs: &Jet1<f32>) -> Jet1<f32> {
        Jet1 {
            value: self * rhs.value,
            derivative: self * rhs.derivative,
        }
    }
}

// Jet1 / Jet1
impl<T: Passive> Div for Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn div(self, rhs: Jet1<T>) -> Jet1<T> {
        // d(a/b) = (a'*b - a*b') / b^2
        let inv_b = T::one() / rhs.value;
        Jet1 {
            value: self.value * inv_b,
            derivative: (self.derivative * rhs.value - self.value * rhs.derivative) * inv_b * inv_b,
        }
    }
}

impl<T: Passive> Div for &Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn div(self, rhs: &Jet1<T>) -> Jet1<T> {
        let inv_b = T::one() / rhs.value;
        Jet1 {
            value: self.value * inv_b,
            derivative: (self.derivative * rhs.value - self.value * rhs.derivative) * inv_b * inv_b,
        }
    }
}

impl<T: Passive> Div<&Jet1<T>> for Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn div(self, rhs: &Jet1<T>) -> Jet1<T> {
        let inv_b = T::one() / rhs.value;
        Jet1 {
            value: self.value * inv_b,
            derivative: (self.derivative * rhs.value - self.value * rhs.derivative) * inv_b * inv_b,
        }
    }
}

impl<T: Passive> Div<Jet1<T>> for &Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn div(self, rhs: Jet1<T>) -> Jet1<T> {
        let inv_b = T::one() / rhs.value;
        Jet1 {
            value: self.value * inv_b,
            derivative: (self.derivative * rhs.value - self.value * rhs.derivative) * inv_b * inv_b,
        }
    }
}

// Jet1 / scalar
impl<T: Passive> Div<T> for Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn div(self, rhs: T) -> Jet1<T> {
        let inv = T::one() / rhs;
        Jet1 {
            value: self.value * inv,
            derivative: self.derivative * inv,
        }
    }
}

impl<T: Passive> Div<T> for &Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn div(self, rhs: T) -> Jet1<T> {
        let inv = T::one() / rhs;
        Jet1 {
            value: self.value * inv,
            derivative: self.derivative * inv,
        }
    }
}

// scalar / Jet1
impl Div<Jet1<f64>> for f64 {
    type Output = Jet1<f64>;
    #[inline]
    fn div(self, rhs: Jet1<f64>) -> Jet1<f64> {
        let inv = 1.0 / rhs.value;
        Jet1 {
            value: self * inv,
            derivative: -self * rhs.derivative * inv * inv,
        }
    }
}

impl Div<&Jet1<f64>> for f64 {
    type Output = Jet1<f64>;
    #[inline]
    fn div(self, rhs: &Jet1<f64>) -> Jet1<f64> {
        let inv = 1.0 / rhs.value;
        Jet1 {
            value: self * inv,
            derivative: -self * rhs.derivative * inv * inv,
        }
    }
}

impl Div<Jet1<f32>> for f32 {
    type Output = Jet1<f32>;
    #[inline]
    fn div(self, rhs: Jet1<f32>) -> Jet1<f32> {
        let inv = 1.0 / rhs.value;
        Jet1 {
            value: self * inv,
            derivative: -self * rhs.derivative * inv * inv,
        }
    }
}

impl Div<&Jet1<f32>> for f32 {
    type Output = Jet1<f32>;
    #[inline]
    fn div(self, rhs: &Jet1<f32>) -> Jet1<f32> {
        let inv = 1.0 / rhs.value;
        Jet1 {
            value: self * inv,
            derivative: -self * rhs.derivative * inv * inv,
        }
    }
}

// Negation
impl<T: Passive> Neg for Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn neg(self) -> Jet1<T> {
        Jet1 {
            value: -self.value,
            derivative: -self.derivative,
        }
    }
}

impl<T: Passive> Neg for &Jet1<T> {
    type Output = Jet1<T>;
    #[inline]
    fn neg(self) -> Jet1<T> {
        Jet1 {
            value: -self.value,
            derivative: -self.derivative,
        }
    }
}

// Compound assignment
impl<T: Passive> AddAssign for Jet1<T> {
    fn add_assign(&mut self, rhs: Jet1<T>) {
        self.value = self.value + rhs.value;
        self.derivative = self.derivative + rhs.derivative;
    }
}

impl<T: Passive> AddAssign<&Jet1<T>> for Jet1<T> {
    fn add_assign(&mut self, rhs: &Jet1<T>) {
        self.value = self.value + rhs.value;
        self.derivative = self.derivative + rhs.derivative;
    }
}

impl<T: Passive> AddAssign<T> for Jet1<T> {
    fn add_assign(&mut self, rhs: T) {
        self.value = self.value + rhs;
    }
}

impl<T: Passive> SubAssign for Jet1<T> {
    fn sub_assign(&mut self, rhs: Jet1<T>) {
        self.value = self.value - rhs.value;
        self.derivative = self.derivative - rhs.derivative;
    }
}

impl<T: Passive> SubAssign<&Jet1<T>> for Jet1<T> {
    fn sub_assign(&mut self, rhs: &Jet1<T>) {
        self.value = self.value - rhs.value;
        self.derivative = self.derivative - rhs.derivative;
    }
}

impl<T: Passive> SubAssign<T> for Jet1<T> {
    fn sub_assign(&mut self, rhs: T) {
        self.value = self.value - rhs;
    }
}

impl<T: Passive> MulAssign for Jet1<T> {
    fn mul_assign(&mut self, rhs: Jet1<T>) {
        let new_deriv = self.derivative * rhs.value + self.value * rhs.derivative;
        self.value = self.value * rhs.value;
        self.derivative = new_deriv;
    }
}

impl<T: Passive> MulAssign<&Jet1<T>> for Jet1<T> {
    fn mul_assign(&mut self, rhs: &Jet1<T>) {
        let new_deriv = self.derivative * rhs.value + self.value * rhs.derivative;
        self.value = self.value * rhs.value;
        self.derivative = new_deriv;
    }
}

impl<T: Passive> MulAssign<T> for Jet1<T> {
    fn mul_assign(&mut self, rhs: T) {
        self.value = self.value * rhs;
        self.derivative = self.derivative * rhs;
    }
}

impl<T: Passive> DivAssign for Jet1<T> {
    fn div_assign(&mut self, rhs: Jet1<T>) {
        let inv_b = T::one() / rhs.value;
        self.derivative =
            (self.derivative * rhs.value - self.value * rhs.derivative) * inv_b * inv_b;
        self.value *= inv_b;
    }
}

impl<T: Passive> DivAssign<&Jet1<T>> for Jet1<T> {
    fn div_assign(&mut self, rhs: &Jet1<T>) {
        let inv_b = T::one() / rhs.value;
        self.derivative =
            (self.derivative * rhs.value - self.value * rhs.derivative) * inv_b * inv_b;
        self.value *= inv_b;
    }
}

impl<T: Passive> DivAssign<T> for Jet1<T> {
    fn div_assign(&mut self, rhs: T) {
        let inv = T::one() / rhs;
        self.value *= inv;
        self.derivative *= inv;
    }
}

// Comparison
impl<T: Passive> PartialEq for Jet1<T> {
    fn eq(&self, other: &Self) -> bool {
        self.value == other.value
    }
}

impl<T: Passive> PartialEq<T> for Jet1<T> {
    fn eq(&self, other: &T) -> bool {
        self.value == *other
    }
}

impl<T: Passive> PartialOrd for Jet1<T> {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.value.partial_cmp(&other.value)
    }
}

impl<T: Passive> PartialOrd<T> for Jet1<T> {
    fn partial_cmp(&self, other: &T) -> Option<std::cmp::Ordering> {
        self.value.partial_cmp(other)
    }
}

impl<T: Passive> fmt::Display for Jet1<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.value)
    }
}

impl<T: Passive> fmt::Debug for Jet1<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Jet1({}, deriv={})", self.value, self.derivative)
    }
}

impl<T: Passive> Default for Jet1<T> {
    fn default() -> Self {
        Jet1::constant(T::zero())
    }
}

// ============================================================================
// NamedJet1<T> — named wrapper over Jet1<T> (generic forward-mode)
// ============================================================================

// `NamedJet1<T>` — named wrapper over `Jet1<T>` (generic forward-mode).
//
// Does NOT carry an `Arc<VarRegistry>` field in release builds. The struct
// layout is a single `inner: Jet1<T>` field plus, under
// `#[cfg(debug_assertions)]` only, a `gen_id: u64` stamped by the owning
// [`NamedForwardTape`] scope for the cross-registry debug guard. Release
// builds are bit-for-bit equivalent to a pure `Jet1<T>` wrapper and carry
// zero atomic-refcount cost per operator.
//
// The only way to obtain a `NamedJet1<T>` is via
// [`NamedForwardTape::declare_jet1`] (then `scope.jet1(handle)`) or
// [`NamedForwardScope::constant_jet1`], which stamp the current TLS
// active-generation into the wrapper.
//
// `Jet1<T>` carries ONE tangent direction — [`derivative`](Self::derivative)
// returns the same value regardless of which `name` is queried. The
// cross-generation check at binary-op time catches mixing values from
// different `NamedForwardTape` scopes in debug builds.

use crate::math;

/// Labeled wrapper around the positional [`Jet1<T>`] type.
///
/// # Example
///
/// ```
/// use xad_rs::{NamedJet1, NamedForwardTape};
///
/// let mut ft = NamedForwardTape::<f64>::new();
/// let x_h = ft.declare_jet1("x", 2.0);
/// let scope = ft.into_scope();
/// let x: &NamedJet1<f64> = scope.jet1(x_h);
/// let f = x * x + x; // f(x) = x^2 + x, f'(x) = 2x + 1 = 5
/// assert_eq!(f.value(), 6.0);
/// assert_eq!(f.derivative("x"), 5.0);
/// ```
#[derive(Clone)]
pub struct NamedJet1<T: Passive> {
    pub(crate) inner: Jet1<T>,
    // NOTE: field name is `gen_id` — `gen` alone is a reserved keyword in
    // Rust 2024 edition. The D-01/D-02 CONTEXT blocks spell it as `gen`;
    // we carry the spelling adjustment forward to satisfy the compiler.
    #[cfg(debug_assertions)]
    pub(crate) gen_id: u64,
}

impl<T: Passive> NamedJet1<T> {
    /// Internal constructor used by `NamedForwardTape::declare_jet1` and
    /// `NamedForwardScope::constant_jet1`. Reads the TLS active
    /// generation (debug builds only) to stamp the `gen` field. Not part
    /// of the public API.
    #[inline]
    pub(crate) fn __from_inner(inner: Jet1<T>) -> Self {
        Self {
            inner,
            #[cfg(debug_assertions)]
            gen_id: crate::forward_tape::current_gen(),
        }
    }

    /// Value part.
    #[inline]
    pub fn value(&self) -> T {
        self.inner.value()
    }

    /// Label-keyed single-direction derivative accessor.
    ///
    /// `Jet1<T>` carries only one tangent direction, so this returns the
    /// current tangent value regardless of which `name` is queried. The
    /// cross-generation debug guard in binary-op impls catches mixing
    /// values from different `NamedForwardTape` scopes; users are
    /// expected to call `derivative(name)` only with names registered on
    /// the tape that constructed this value.
    #[inline]
    pub fn derivative(&self, _name: &str) -> T {
        self.inner.derivative()
    }

    /// Escape hatch: direct access to the inner positional `Jet1<T>`.
    #[inline]
    pub fn inner(&self) -> &Jet1<T> {
        &self.inner
    }

    // ============ Elementary math delegations ============
    // Forward to the free-function `math::fwd::*` surface, which operates
    // on `&Jet1<T>` and returns `Jet1<T>`. Each method preserves the
    // parent's generation stamp explicitly (debug builds) to avoid a TLS
    // read on the hot path.

    /// Natural exponential, preserving the parent scope's generation.
    #[inline]
    pub fn exp(&self) -> Self {
        Self {
            inner: math::fwd::exp(&self.inner),
            #[cfg(debug_assertions)]
            gen_id: self.gen_id,
        }
    }

    /// Natural logarithm, preserving the parent scope's generation.
    #[inline]
    pub fn ln(&self) -> Self {
        Self {
            inner: math::fwd::ln(&self.inner),
            #[cfg(debug_assertions)]
            gen_id: self.gen_id,
        }
    }

    /// Square root, preserving the parent scope's generation.
    #[inline]
    pub fn sqrt(&self) -> Self {
        Self {
            inner: math::fwd::sqrt(&self.inner),
            #[cfg(debug_assertions)]
            gen_id: self.gen_id,
        }
    }

    /// Sine, preserving the parent scope's generation.
    #[inline]
    pub fn sin(&self) -> Self {
        Self {
            inner: math::fwd::sin(&self.inner),
            #[cfg(debug_assertions)]
            gen_id: self.gen_id,
        }
    }

    /// Cosine, preserving the parent scope's generation.
    #[inline]
    pub fn cos(&self) -> Self {
        Self {
            inner: math::fwd::cos(&self.inner),
            #[cfg(debug_assertions)]
            gen_id: self.gen_id,
        }
    }

    /// Tangent, preserving the parent scope's generation.
    #[inline]
    pub fn tan(&self) -> Self {
        Self {
            inner: math::fwd::tan(&self.inner),
            #[cfg(debug_assertions)]
            gen_id: self.gen_id,
        }
    }

    /// Standard normal CDF, preserving the parent scope's generation.
    #[inline]
    pub fn norm_cdf(&self) -> Self {
        Self {
            inner: math::fwd::norm_cdf(&self.inner),
            #[cfg(debug_assertions)]
            gen_id: self.gen_id,
        }
    }

    /// Inverse standard normal CDF, preserving the parent scope's generation.
    #[inline]
    pub fn inv_norm_cdf(&self) -> Self {
        Self {
            inner: math::fwd::inv_norm_cdf(&self.inner),
            #[cfg(debug_assertions)]
            gen_id: self.gen_id,
        }
    }
}

impl<T: Passive> fmt::Debug for NamedJet1<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("NamedJet1")
            .field("value", &self.inner.value())
            .field("derivative", &self.inner.derivative())
            .finish()
    }
}

impl<T: Passive> fmt::Display for NamedJet1<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "NamedJet1({})", self.inner.value())
    }
}

// ============ Operator overloads — hand-written ============
// No shared op-stamping macro is used: the struct does not carry an
// `Arc` registry field on the per-value wrapper. The four reference
// variants (owned/owned, ref/ref, owned/ref, ref/owned) plus scalar-RHS
// variants are stamped explicitly via a local `__named_freal_binop!`
// macro, modelled on `__named_areal_binop!` in `src/named/areal.rs`
// but generalised over `<T: Passive>`. Each impl performs a debug-only
// `check_gen` between the two operands' generations, then constructs
// the result preserving the LHS's generation stamp.

macro_rules! __named_freal_binop {
    ($trait:ident, $method:ident, $op:tt) => {
        impl<T: Passive> ::core::ops::$trait<NamedJet1<T>> for NamedJet1<T> {
            type Output = NamedJet1<T>;
            #[inline]
            fn $method(self, rhs: NamedJet1<T>) -> NamedJet1<T> {
                #[cfg(debug_assertions)]
                crate::forward_tape::check_gen(self.gen_id, rhs.gen_id);
                NamedJet1 {
                    inner: self.inner $op rhs.inner,
                    #[cfg(debug_assertions)]
                    gen_id: self.gen_id,
                }
            }
        }
        impl<T: Passive> ::core::ops::$trait<&NamedJet1<T>> for &NamedJet1<T> {
            type Output = NamedJet1<T>;
            #[inline]
            fn $method(self, rhs: &NamedJet1<T>) -> NamedJet1<T> {
                #[cfg(debug_assertions)]
                crate::forward_tape::check_gen(self.gen_id, rhs.gen_id);
                NamedJet1 {
                    inner: &self.inner $op &rhs.inner,
                    #[cfg(debug_assertions)]
                    gen_id: self.gen_id,
                }
            }
        }
        impl<T: Passive> ::core::ops::$trait<&NamedJet1<T>> for NamedJet1<T> {
            type Output = NamedJet1<T>;
            #[inline]
            fn $method(self, rhs: &NamedJet1<T>) -> NamedJet1<T> {
                #[cfg(debug_assertions)]
                crate::forward_tape::check_gen(self.gen_id, rhs.gen_id);
                NamedJet1 {
                    inner: self.inner $op &rhs.inner,
                    #[cfg(debug_assertions)]
                    gen_id: self.gen_id,
                }
            }
        }
        impl<T: Passive> ::core::ops::$trait<NamedJet1<T>> for &NamedJet1<T> {
            type Output = NamedJet1<T>;
            #[inline]
            fn $method(self, rhs: NamedJet1<T>) -> NamedJet1<T> {
                #[cfg(debug_assertions)]
                crate::forward_tape::check_gen(self.gen_id, rhs.gen_id);
                NamedJet1 {
                    inner: &self.inner $op rhs.inner,
                    #[cfg(debug_assertions)]
                    gen_id: self.gen_id,
                }
            }
        }
        impl<T: Passive> ::core::ops::$trait<T> for NamedJet1<T> {
            type Output = NamedJet1<T>;
            #[inline]
            fn $method(self, rhs: T) -> NamedJet1<T> {
                NamedJet1 {
                    inner: self.inner $op rhs,
                    #[cfg(debug_assertions)]
                    gen_id: self.gen_id,
                }
            }
        }
        impl<T: Passive> ::core::ops::$trait<T> for &NamedJet1<T> {
            type Output = NamedJet1<T>;
            #[inline]
            fn $method(self, rhs: T) -> NamedJet1<T> {
                NamedJet1 {
                    inner: &self.inner $op rhs,
                    #[cfg(debug_assertions)]
                    gen_id: self.gen_id,
                }
            }
        }
    };
}

__named_freal_binop!(Add, add, +);
__named_freal_binop!(Sub, sub, -);
__named_freal_binop!(Mul, mul, *);
__named_freal_binop!(Div, div, /);

impl<T: Passive> ::core::ops::Neg for NamedJet1<T> {
    type Output = NamedJet1<T>;
    #[inline]
    fn neg(self) -> NamedJet1<T> {
        NamedJet1 {
            inner: -self.inner,
            #[cfg(debug_assertions)]
            gen_id: self.gen_id,
        }
    }
}
impl<T: Passive> ::core::ops::Neg for &NamedJet1<T> {
    type Output = NamedJet1<T>;
    #[inline]
    fn neg(self) -> NamedJet1<T> {
        NamedJet1 {
            inner: -&self.inner,
            #[cfg(debug_assertions)]
            gen_id: self.gen_id,
        }
    }
}

// ============ Scalar-on-LHS hand-written impls for f64 and f32 ============
// Two concrete types (f64, f32), two variants (owned, ref), four ops =
// 16 impls. Inner Jet1<T> already provides `f64 op Jet1<f64>` and
// `f32 op Jet1<f32>` for owned + ref, so delegation is direct. Each
// result preserves the RHS's generation stamp (debug builds only).

macro_rules! __named_freal_scalar_lhs {
    ($scalar:ty) => {
        impl ::core::ops::Add<NamedJet1<$scalar>> for $scalar {
            type Output = NamedJet1<$scalar>;
            #[inline]
            fn add(self, rhs: NamedJet1<$scalar>) -> NamedJet1<$scalar> {
                NamedJet1 {
                    inner: self + rhs.inner,
                    #[cfg(debug_assertions)]
                    gen_id: rhs.gen_id,
                }
            }
        }
        impl ::core::ops::Add<&NamedJet1<$scalar>> for $scalar {
            type Output = NamedJet1<$scalar>;
            #[inline]
            fn add(self, rhs: &NamedJet1<$scalar>) -> NamedJet1<$scalar> {
                NamedJet1 {
                    inner: self + &rhs.inner,
                    #[cfg(debug_assertions)]
                    gen_id: rhs.gen_id,
                }
            }
        }
        impl ::core::ops::Sub<NamedJet1<$scalar>> for $scalar {
            type Output = NamedJet1<$scalar>;
            #[inline]
            fn sub(self, rhs: NamedJet1<$scalar>) -> NamedJet1<$scalar> {
                NamedJet1 {
                    inner: self - rhs.inner,
                    #[cfg(debug_assertions)]
                    gen_id: rhs.gen_id,
                }
            }
        }
        impl ::core::ops::Sub<&NamedJet1<$scalar>> for $scalar {
            type Output = NamedJet1<$scalar>;
            #[inline]
            fn sub(self, rhs: &NamedJet1<$scalar>) -> NamedJet1<$scalar> {
                NamedJet1 {
                    inner: self - &rhs.inner,
                    #[cfg(debug_assertions)]
                    gen_id: rhs.gen_id,
                }
            }
        }
        impl ::core::ops::Mul<NamedJet1<$scalar>> for $scalar {
            type Output = NamedJet1<$scalar>;
            #[inline]
            fn mul(self, rhs: NamedJet1<$scalar>) -> NamedJet1<$scalar> {
                NamedJet1 {
                    inner: self * rhs.inner,
                    #[cfg(debug_assertions)]
                    gen_id: rhs.gen_id,
                }
            }
        }
        impl ::core::ops::Mul<&NamedJet1<$scalar>> for $scalar {
            type Output = NamedJet1<$scalar>;
            #[inline]
            fn mul(self, rhs: &NamedJet1<$scalar>) -> NamedJet1<$scalar> {
                NamedJet1 {
                    inner: self * &rhs.inner,
                    #[cfg(debug_assertions)]
                    gen_id: rhs.gen_id,
                }
            }
        }
        impl ::core::ops::Div<NamedJet1<$scalar>> for $scalar {
            type Output = NamedJet1<$scalar>;
            #[inline]
            fn div(self, rhs: NamedJet1<$scalar>) -> NamedJet1<$scalar> {
                NamedJet1 {
                    inner: self / rhs.inner,
                    #[cfg(debug_assertions)]
                    gen_id: rhs.gen_id,
                }
            }
        }
        impl ::core::ops::Div<&NamedJet1<$scalar>> for $scalar {
            type Output = NamedJet1<$scalar>;
            #[inline]
            fn div(self, rhs: &NamedJet1<$scalar>) -> NamedJet1<$scalar> {
                NamedJet1 {
                    inner: self / &rhs.inner,
                    #[cfg(debug_assertions)]
                    gen_id: rhs.gen_id,
                }
            }
        }
    };
}

__named_freal_scalar_lhs!(f64);
__named_freal_scalar_lhs!(f32);

// ============================================================================
// impl Real for Jet1<f64>
// ============================================================================
//
// Delegates to `crate::math::fwd::*` free functions which propagate the
// tangent component via the chain rule. `powf` uses the two-Jet1 `pow` (not
// the Jet1-and-passive `powf`) because `Real::powf` requires `exponent: Self`.

impl crate::real::Real for Jet1<f64> {
    type Passive = f64;

    #[inline]
    fn value(&self) -> f64 {
        self.value
    }
    #[inline]
    fn ln(&self) -> Self {
        crate::math::fwd::ln(self)
    }
    #[inline]
    fn exp(&self) -> Self {
        crate::math::fwd::exp(self)
    }
    #[inline]
    fn sqrt(&self) -> Self {
        crate::math::fwd::sqrt(self)
    }
    #[inline]
    fn powf(&self, exponent: Self) -> Self {
        crate::math::fwd::pow(self, &exponent)
    }
    #[inline]
    fn powi(&self, exponent: i32) -> Self {
        crate::math::fwd::powi(self, exponent)
    }
    #[inline]
    fn sin(&self) -> Self {
        crate::math::fwd::sin(self)
    }
    #[inline]
    fn cos(&self) -> Self {
        crate::math::fwd::cos(self)
    }
}