DoubleDouble Structure

public readonly struct DoubleDouble : IEquatable<DoubleDouble>, 
	IComparable<DoubleDouble>

Public Structure DoubleDouble
	Implements IEquatable(Of DoubleDouble), IComparable(Of DoubleDouble)

public value class DoubleDouble : IEquatable<DoubleDouble>, 
	IComparable<DoubleDouble>

[<SealedAttribute>]
type DoubleDouble = 
    struct
        inherit ValueType
        interface IEquatable<DoubleDouble>
        interface IComparable<DoubleDouble>
    end

Inheritance

Object    ValueType    DoubleDouble

Implements

IComparableDoubleDouble, IEquatableDoubleDouble

The DoubleDouble structure uses two Double values to achieve twice the precision with which a floating point number can be stored and manipulated as compared to to the Double structure, approximately 31 decimal digits.

Of all the extended precision floating point systems, double double is the fastest when implemented in software. A typical floating point operation using DoubleDoubles is just 3-4 times slower than using Doubles.

To instantiate a DoubleDouble, you can use TryParse(String, DoubleDouble), or Parse(String), or the constructor DoubleDouble(String) to parse the text representation of the decimal value you want. If the value you want can be represented as a Double or Int32 or other built in numeric type, you can cast that value to a DoubleDouble.

When casting a Double to a DoubleDouble, there is a gotcha that you must be careful to avoid. Suppose you write DoubleDouble x = 0.2 or DoubleDouble x = 1.0 / 5.0. You might think that this produces the DoubleDouble representation of 1/5, but you would be wrong. The problem is that the compiler intreprets 0.2 or 1.0/5.0 as Doubles, and 1/5th is not exactly representable as a double, since it is not a rational number with a power-of-two denominator. Double's best attempt at 1/5th is 3602879701896397 X 2^^-54 = 0.20000000000000001110223024625157..., which is accurate to 16 decimal digits, but not to 32. Therefore when it is cast to a DoubleDouble it is much farther away from 1/5th than DoubleDouble can achieve. To obtain 1/5th to the accuracy of a DoubleDouble, you must write DoubleDouble x = new DoubleDouble("0.2") or DoubleDouble x = (DoubleDouble) 1 / 5. (The latter works because 1 and 5 are exactly representable and the division is performed as DoubleDouble division. All integers in range, indeed all rational numbers with in-range numerators and power-of-two denominators, are exactly representable. So, for example, DoubleDouble x = 0.25does work as expected, because 1/4 is exactly representable. But to avoid the gotcha it's best to simply train yourself to avoid assigning DoubleDouble variables from factional Double values.)

Many of the mathematical functions which are implemented for Double arguments by static methods of the Math class are implemented for DoubleDouble arguments by static methods of the DoubleDouble type itself, for example Sqrt(DoubleDouble) and Log(DoubleDouble). Some of the advanced functions which are implemented for Double arguments by static methods of the AdvancedMath class are implemented for DoubleDouble arguments by static methods of the AdvancedDoubleDoubleMath class.

You may wonder why DoubleDouble is not simply named "Quad". The reason is that "Quad" would propertly refer to an implementation of the IEEE 754 quadruple-precision binary floating point format, which would have not only the extended presion of DoubleDouble, but also an extended range (up to 10⁴⁹³²).

Reference