Struct Double 

pub struct Double;

Double-double: DD, DV, Du, Jet<N>, DDLu; its dot product is the plain sum of double-double products

Trait Implementations

impl Clone for Double

fn clone(&self) -> Double

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Double

impl Debug for Double

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

Formats the value using the given formatter.

impl<S> Precision<S> for Double

where S: Simd,

const PARTS: usize = 2

the number of f64 parts of a scalar: 2 for double-double, 4 for quad-double, 8 for octo-double

const ZERO: DD = DD::ZERO

zero and one

const ONE: DD = DD::ONE

type Scalar = DD

the scalar: DD, QD, OD

type V = DV<S>

8 scalars in lanes: DV, QV, OV

type U = Du<S>

forward-mode dual, value and one tangent in this precision: Du, Qu, Ou

type J<const N: usize> = Jet<S, N>

truncated power series with N coefficients in this precision: Jet<N>, QJet<N>, OJet<N>

type Lu = DDLu

dense LU with partial pivoting in this precision: DDLu, QDLu, ODLu

fn new(p: &[f64]) -> DD

a scalar from up to PARTS parts, the missing ones zero, renormalized (QD::new, OD::new)

fn from_raw(p: &[f64]) -> DD

a scalar from exactly PARTS parts as they are, not renormalized (the struct literal QD { x }, OD { x })

fn part(x: DD, q: usize) -> f64

part q of a scalar

fn from_dd(d: DD) -> DD

from double-double, exactly

fn to_dd(x: DD) -> DD

rounded to double-double

fn dot(pairs: impl Iterator<Item = (DD, DD)>) -> DD

sum of the products a b over the pairs, in this precision’s accumulator (QdAcc, OdAcc): add_prod per pair, finish at the end

fn splat(x: DD) -> DV<S>

the scalar in every lane (QV::splat, OV::splat)

fn dual(v: DV<S>, d: DV<S>) -> Du<S>

a dual from its value and tangent lanes

fn coef<L>(l: L, k: usize) -> DV<S>

where L: Lane<S = S>,

coefficient k of a lane in this precision (Lane::coef_qd, Lane::coef_od)

fn set_coef<L>(l: &mut L, k: usize, c: DV<S>)

where L: Lane<S = S>,

set coefficient k of a lane from this precision (Lane::set_coef_qd, Lane::set_coef_od)

fn load_field<const B: usize>(parts: &[&[f64]]) -> Fl<DV<S>, B>

a field of 8 B values from PARTS part arrays of at least 8 B values each (Fl::load_parts, Fl::load_parts_od)

fn field_get<const B: usize>(f: &Fl<DV<S>, B>, j: usize) -> DD

value j of a field (Fl::get)

fn field_coef<L, const B: usize>(f: &Fl<L, B>, k: usize) -> Fl<DV<S>, B>

where L: Lane<S = S>,

coefficient k of a field in this precision (Fl::coef_qd, Fl::coef_od)

fn field_set_coef<L, const B: usize>( f: &mut Fl<L, B>, k: usize, c: &Fl<DV<S>, B>, )

where L: Lane<S = S>,

set coefficient k of a field from this precision (Fl::set_coef_qd, Fl::set_coef_od)

fn field_dual<const B: usize>( v: &Fl<DV<S>, B>, t: &Fl<DV<S>, B>, ) -> Fl<Du<S>, B>

a dual field from its values and tangents, exactly (Fl::from_vt_qd, Fl::from_vt_od)

fn lu_factor( n: usize, ld: usize, c: Vec<Vec<f64>>, par: bool, ) -> Result<DDLu, String>

factor the n x n matrix of PARTS column-major part arrays with leading dimension ld (QDLu::factor, ODLu::factor). Each entry’s parts must be normalized, as new returns them: the pivot search reads the leading parts only.

fn lu_solve(lu: &DDLu, b: &mut [DD])

solve in place with the factored matrix (QDLu::solve, ODLu::solve)