Struct Df64 

pub struct Df64 {
    pub hi: f64,
    pub lo: f64,
}

A real scalar carrying a high and a low f64 component.

hi holds the rounded value and lo the exact residual, so hi + lo is the represented real number.

Examples

use tenferro_df64_proof::Df64;

let carried = Df64 { hi: 1.0, lo: 2f64.powi(-80) };
assert_eq!(carried.narrow_to_f64(), 1.0);
assert_ne!(carried, Df64::from_f64(1.0));

Fields

hi: f64

Rounded component.

lo: f64

Exact residual component.

Implementations

impl Df64

pub fn from_f64(value: f64) -> Self

Build a scalar with no low component.

Examples

use tenferro_df64_proof::Df64;

assert_eq!(Df64::from_f64(1.5), Df64 { hi: 1.5, lo: 0.0 });

pub fn zero() -> Self

Additive identity.

Examples

use tenferro_df64_proof::Df64;

assert_eq!(Df64::zero(), Df64 { hi: 0.0, lo: 0.0 });

pub fn narrow_to_f64(self) -> f64

Explicitly narrow to f64, discarding the low component.

This is a numerical conversion, not a reinterpretation: it allocates nothing and reads only the rounded component.

Examples

use tenferro_df64_proof::Df64;

// The low component is deliberately dropped, and is not recovered.
assert_eq!(Df64 { hi: 1.0, lo: 2f64.powi(-80) }.narrow_to_f64(), 1.0);

pub fn ratio(self, divisor: Self) -> Self

Quotient, refined to the full two-component precision.

The first component of the result is the ordinary f64 quotient and the remaining error is recovered by two Newton corrections evaluated in the two-component arithmetic, so the quotient carries both components.

Examples

use tenferro_df64_proof::Df64;

// One divided by three is not a binary fraction, and the low component holds
// the part an `f64` quotient cannot.
let third = Df64::from_f64(1.0).ratio(Df64::from_f64(3.0));
assert_eq!(third.hi, 1.0 / 3.0);
assert_ne!(third.lo, 0.0);
assert!((third * Df64::from_f64(3.0) - Df64::from_f64(1.0)).abs_hi() < 1e-31);

pub fn sqrt(self) -> Self

Square root, refined to the full two-component precision.

A negative operand follows IEEE: the result is NaN with a zero low component.

Examples

use tenferro_df64_proof::Df64;

let root = Df64::from_f64(2.0).sqrt();
assert_eq!(root.hi, 2.0_f64.sqrt());
// Squaring recovers two to a precision an `f64` root cannot reach.
assert!((root * root - Df64::from_f64(2.0)).abs_hi() < 1e-31);
assert!(Df64::from_f64(-1.0).sqrt().hi.is_nan());

pub fn abs_hi(self) -> f64

Absolute value of the rounded component.

This is the scale a convergence test uses; it does not widen the represented value.

Examples

use tenferro_df64_proof::Df64;

assert_eq!(Df64 { hi: -2.0, lo: 1.0 }.abs_hi(), 2.0);

Trait Implementations

impl Add for Df64

fn add(self, other: Self) -> Self

Exact addition of two expansions.

type Output = Df64

The resulting type after applying the + operator.

impl BinaryScalarOp<Df64> for Df64Add

fn apply(lhs: Df64, rhs: Df64) -> Df64

Apply the operation.

impl Clone for Df64

fn clone(&self) -> Df64

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Df64

impl Debug for Df64

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

Formats the value using the given formatter.

impl Default for Df64

fn default() -> Df64

Returns the “default value” for a type.

impl Div for Df64

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

Two-component quotient, refined to both components.

type Output = Df64

The resulting type after applying the / operator.

impl Mul for Df64

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

Two-component product: the exact leading product plus the first-order corrections, which is what the contract’s arithmetic promises.

type Output = Df64

The resulting type after applying the * operator.

impl Neg for Df64

type Output = Df64

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for Df64

fn eq(&self, other: &Df64) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Scalar for Df64

const DOMAIN: ScalarDomain = tenferro_tensor_core::ScalarDomain::Field

Algebra of this scalar’s ordinary arithmetic.

impl ScalarArithmetic for Df64

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

First-order expansion product: the exact leading product plus the first-order correction terms.

fn scalar_zero() -> Self

Additive identity.

fn scalar_one() -> Self

Multiplicative identity.

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

Sum under this scalar’s own semantics.

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

Difference under this scalar’s own semantics.

impl StructuralPartialEq for Df64

impl Sub for Df64

fn sub(self, other: Self) -> Self

Exact subtraction.

type Output = Df64

The resulting type after applying the - operator.