Struct DoubleDouble 

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

Double-double precision floating-point number.

Represents the unevaluated sum hi + lo where |lo| ≤ 0.5 ulp(hi). Provides approximately 31 decimal digits of precision using two f64 values.

Constants

use scirs2_core::arithmetic::DoubleDouble;

let zero = DoubleDouble::ZERO;
let one = DoubleDouble::ONE;
let pi = DoubleDouble::PI;
let e = DoubleDouble::E;

Fields

hi: f64

High-order word (most significant bits).

lo: f64

Low-order word (error term; |lo| ≤ 0.5 ulp(hi)).

Implementations

impl DoubleDouble

pub const ZERO: Self

Zero.

pub const ONE: Self

One.

pub const PI: Self

π to double-double precision. Value: 3.14159265358979323846264338327950288…

pub const E: Self

e = exp(1) to double-double precision. Value: 2.71828182845904523536028747135266249…

pub fn new(x: f64) -> Self

Construct from a single f64 (error term is zero).

pub fn from_f64(hi: f64, lo: f64) -> Self

Construct from explicit (hi, lo) parts with renormalization.

pub fn from_i64(x: i64) -> Self

Construct from an i64 integer exactly.

pub fn to_f64(self) -> f64

Convert to f64 — returns only the high-order word.

pub fn to_f128_approx(self) -> f64

Convert to f64 with compensated rounding (returns hi + lo). Loses precision in the conversion but is numerically more accurate than to_f64.

pub fn is_finite(self) -> bool

Returns true if both hi and lo are finite.

pub fn is_nan(self) -> bool

Returns true if hi is NaN.

pub fn is_zero(self) -> bool

Returns true if both components are zero.

pub fn abs(self) -> Self

Absolute value.

pub fn negate(self) -> Self

Negate: returns −self.

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

Add self + rhs using double-double arithmetic.

Uses the precise algorithm (Shewchuk 1997).

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

Subtract self - rhs.

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

Multiply self * rhs.

Uses Dekker’s algorithm with TwoProd.

pub fn div(self, rhs: Self) -> CoreResult<Self>

Divide self / rhs.

Returns Err if rhs is zero.

pub fn mul_f64(self, rhs: f64) -> Self

Multiply self × rhs where rhs is a plain f64.

Slightly cheaper than the full double-double multiplication.

pub fn square(self) -> Self

Square of self (cheaper than mul(self, self)).

pub fn sqrt(self) -> CoreResult<Self>

Square root via Newton-Raphson iteration in double-double precision.

Returns Err for negative inputs.

pub fn exp(self) -> CoreResult<Self>

Compute e^self using range reduction and Taylor series in DD arithmetic.

Range reduction: x = k*ln(2) + r, then exp(x) = 2^k * exp(r).

pub fn ln(self) -> CoreResult<Self>

Compute ln(self) for positive inputs.

Uses a Newton refinement of the f64 result.

pub fn sin(self) -> CoreResult<Self>

Compute sin(self) in double-double precision.

Returns only the sine component. For simultaneous sin/cos, prefer sincos.

pub fn cos(self) -> CoreResult<Self>

Compute cos(self) in double-double precision.

Returns only the cosine component. For simultaneous sin/cos, prefer sincos.

pub fn sincos(self) -> CoreResult<(Self, Self)>

Compute (sin(self), cos(self)) simultaneously.

Uses argument reduction to [-π/4, π/4] followed by Taylor series.

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

Integer power via repeated squaring.

Handles negative exponents by inversion.

pub fn compare(&self, rhs: &Self) -> Ordering

Compare self with rhs for ordering.

pub fn renorm(hi: f64, lo: f64) -> Self

Renormalize hi + lo so the invariant |lo| ≤ 0.5 ulp(hi) holds.

Trait Implementations

impl Add for DoubleDouble

type Output = DoubleDouble

The resulting type after applying the + operator.

fn add(self, rhs: DoubleDouble) -> DoubleDouble

Performs the + operation.

impl Clone for DoubleDouble

fn clone(&self) -> DoubleDouble

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DoubleDouble

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

Formats the value using the given formatter.

impl Default for DoubleDouble

fn default() -> DoubleDouble

Returns the “default value” for a type.

impl Display for DoubleDouble

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

Formats the value using the given formatter.

impl Div for DoubleDouble

Division via div; returns DoubleDouble { hi: NaN, lo: NaN } if rhs is zero. Prefer DoubleDouble::div for error handling.

type Output = DoubleDouble

The resulting type after applying the / operator.

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

Performs the / operation.

impl From<f64> for DoubleDouble

fn from(x: f64) -> DoubleDouble

Converts to this type from the input type.

impl From<i32> for DoubleDouble

fn from(x: i32) -> DoubleDouble

Converts to this type from the input type.

impl From<i64> for DoubleDouble

fn from(x: i64) -> DoubleDouble

Converts to this type from the input type.

impl Mul for DoubleDouble

type Output = DoubleDouble

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for DoubleDouble

type Output = DoubleDouble

The resulting type after applying the - operator.

fn neg(self) -> DoubleDouble

Performs the unary - operation.

impl PartialEq for DoubleDouble

fn eq(&self, other: &Self) -> 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 PartialOrd for DoubleDouble

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 Sub for DoubleDouble

type Output = DoubleDouble

The resulting type after applying the - operator.

fn sub(self, rhs: DoubleDouble) -> DoubleDouble

Performs the - operation.

impl Copy for DoubleDouble