279 lines
9.7 KiB
C#
279 lines
9.7 KiB
C#
// Printing and parsing of DoubleDoubleSample, by Marek Fiser.
|
|
// Source: https://marekfiser.com/blog/double-double-arithmetic
|
|
// Licensed under CC BY 4.0: https://creativecommons.org/licenses/by/4.0/
|
|
// Changes for this benchmark: copied into this project, kept in the
|
|
// Just.PreciseMath.PerformanceComparison.Reference namespace, and the file and type
|
|
// renamed to DoubleDoubleSample.Format.cs and DoubleDoubleSample.
|
|
// Printing 31 correct decimal digits requires computing them exactly, which is done with
|
|
// BigInteger (part of the BCL, so still no NuGet dependencies).
|
|
using System.Globalization;
|
|
using System.Numerics;
|
|
using System.Text;
|
|
|
|
namespace Just.PreciseMath.PerformanceComparison.Reference;
|
|
|
|
public readonly partial struct DoubleDoubleSample {
|
|
|
|
/// <summary>Significant digits <see cref="ToString()"/> prints: enough to round-trip any
|
|
/// value whose two components are contiguous (see <see cref="Parse"/>).</summary>
|
|
private const int DEFAULT_DIGITS = 36;
|
|
|
|
|
|
/// <summary>Formats with <see cref="DEFAULT_DIGITS"/> significant digits.</summary>
|
|
public override string ToString() {
|
|
return ToString(DEFAULT_DIGITS);
|
|
}
|
|
|
|
/// <summary>Formats with the given number of significant decimal digits, correctly rounded.</summary>
|
|
public string ToString(int significantDigits) {
|
|
ArgumentOutOfRangeException.ThrowIfLessThan(significantDigits, 1);
|
|
|
|
if (!double.IsFinite(m_hi)) {
|
|
return m_hi.ToString(CultureInfo.InvariantCulture);
|
|
}
|
|
|
|
(BigInteger numerator, BigInteger denominator) = toRational(this);
|
|
return formatRational(numerator, denominator, significantDigits);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Formats the exact value. A double-double is a sum of two binary fractions, so it
|
|
/// always has a finite decimal expansion, but it can be hundreds of digits long when the
|
|
/// components are far apart.
|
|
/// </summary>
|
|
public string ToStringExact() {
|
|
if (!double.IsFinite(m_hi)) {
|
|
return m_hi.ToString(CultureInfo.InvariantCulture);
|
|
}
|
|
|
|
(BigInteger numerator, BigInteger denominator) = toRational(this);
|
|
if (numerator.IsZero) {
|
|
return "0";
|
|
}
|
|
|
|
// The denominator is a power of two, so multiplying by the matching power of five
|
|
// turns it into a power of ten, which gives the decimal digits directly.
|
|
int twos = (int)(denominator.GetBitLength() - 1);
|
|
BigInteger scaled = BigInteger.Abs(numerator) * BigInteger.Pow(5, twos);
|
|
string digits = scaled.ToString(CultureInfo.InvariantCulture).PadLeft(twos + 1, '0');
|
|
string sign = numerator.Sign < 0 ? "-" : "";
|
|
if (twos == 0) {
|
|
return sign + digits;
|
|
}
|
|
|
|
string result = sign + digits[..^twos] + "." + digits[^twos..];
|
|
return result.TrimEnd('0').TrimEnd('.');
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses a decimal string to the nearest double-double. The value is built exactly as a
|
|
/// rational, then rounded once into each component. Round-trips with
|
|
/// <see cref="ToString()"/> for every value whose components are contiguous;
|
|
/// a hand-built pair such as (1.0, 1e-300) holds more information than 36 digits can
|
|
/// represent.
|
|
/// </summary>
|
|
public static DoubleDoubleSample Parse(string text) {
|
|
(BigInteger numerator, BigInteger denominator) = parseRational(text);
|
|
double hi = toNearestDouble(numerator, denominator);
|
|
if (!double.IsFinite(hi)) {
|
|
return FromDouble(hi);
|
|
}
|
|
|
|
// Subtract the leading component exactly and round the remainder into the trailing one.
|
|
(BigInteger hiNumerator, BigInteger hiDenominator) = toRational(FromDouble(hi));
|
|
BigInteger restNumerator = numerator * hiDenominator - hiNumerator * denominator;
|
|
BigInteger restDenominator = denominator * hiDenominator;
|
|
double lo = toNearestDouble(restNumerator, restDenominator);
|
|
return FromTwoDoubles(hi, lo);
|
|
}
|
|
|
|
/// <summary>The exact value of a double-double as a rational (the denominator is a power of two).</summary>
|
|
private static (BigInteger Numerator, BigInteger Denominator) toRational(DoubleDoubleSample value) {
|
|
(BigInteger hiNumerator, BigInteger hiDenominator) = toRational(value.m_hi);
|
|
(BigInteger loNumerator, BigInteger loDenominator) = toRational(value.m_lo);
|
|
return (hiNumerator * loDenominator + loNumerator * hiDenominator, hiDenominator * loDenominator);
|
|
}
|
|
|
|
/// <summary>The exact value of a finite double as a rational, from its bits.</summary>
|
|
private static (BigInteger Numerator, BigInteger Denominator) toRational(double value) {
|
|
long bits = BitConverter.DoubleToInt64Bits(value);
|
|
int exponent = (int)((bits >> 52) & 0x7FF);
|
|
long mantissa = bits & 0xF_FFFF_FFFF_FFFFL;
|
|
if (exponent == 0) {
|
|
exponent = -1074; // subnormal: no implicit leading bit
|
|
} else {
|
|
mantissa |= 1L << 52;
|
|
exponent -= 1075;
|
|
}
|
|
|
|
BigInteger numerator = bits < 0 ? -mantissa : mantissa;
|
|
return exponent >= 0
|
|
? (numerator << exponent, BigInteger.One)
|
|
: (numerator, BigInteger.One << -exponent);
|
|
}
|
|
|
|
/// <summary>Rounds an exact rational to the nearest double, ties to even.</summary>
|
|
private static double toNearestDouble(BigInteger numerator, BigInteger denominator) {
|
|
if (numerator.IsZero) {
|
|
return 0.0;
|
|
}
|
|
|
|
int sign = numerator.Sign;
|
|
numerator = BigInteger.Abs(numerator);
|
|
|
|
// Scale so that the quotient is in [2^52, 2^54). One integer division then gives all
|
|
// bits of the significand plus the remainder needed for the rounding.
|
|
long exponent = numerator.GetBitLength() - denominator.GetBitLength() - 53;
|
|
if (exponent > 0) {
|
|
denominator <<= (int)exponent;
|
|
} else {
|
|
numerator <<= (int)-exponent;
|
|
}
|
|
|
|
BigInteger quotient = BigInteger.DivRem(numerator, denominator, out BigInteger remainder);
|
|
if (quotient.GetBitLength() > 53) {
|
|
// One bit too many. Move it to the exponent and add the dropped bit to the
|
|
// remainder so that the rounding decision below stays exact.
|
|
if (!quotient.IsEven) {
|
|
remainder += denominator;
|
|
}
|
|
quotient >>= 1;
|
|
denominator <<= 1;
|
|
exponent++;
|
|
}
|
|
|
|
int comparison = (remainder << 1).CompareTo(denominator);
|
|
if (comparison > 0 || (comparison == 0 && !quotient.IsEven)) {
|
|
quotient++;
|
|
if (quotient.GetBitLength() > 53) {
|
|
quotient >>= 1;
|
|
exponent++;
|
|
}
|
|
}
|
|
|
|
return sign * Math.ScaleB((double)quotient, (int)exponent);
|
|
}
|
|
|
|
/// <summary>Parses a decimal string such as "-1.25e-7" into an exact rational.</summary>
|
|
private static (BigInteger Numerator, BigInteger Denominator) parseRational(string text) {
|
|
text = text.Trim();
|
|
if (text.Length == 0) {
|
|
throw new FormatException("Empty input.");
|
|
}
|
|
|
|
int index = 0;
|
|
bool negative = text[index] == '-';
|
|
if (negative || text[index] == '+') {
|
|
index++;
|
|
}
|
|
|
|
BigInteger mantissa = BigInteger.Zero;
|
|
int fractionDigits = 0;
|
|
bool seenDot = false;
|
|
bool seenDigit = false;
|
|
|
|
for (; index < text.Length; index++) {
|
|
char c = text[index];
|
|
if (c == '.') {
|
|
if (seenDot) {
|
|
throw new FormatException($"Two decimal points in '{text}'.");
|
|
}
|
|
seenDot = true;
|
|
} else if (c is >= '0' and <= '9') {
|
|
mantissa = mantissa * 10 + (c - '0');
|
|
seenDigit = true;
|
|
if (seenDot) {
|
|
fractionDigits++;
|
|
}
|
|
} else if (c is 'e' or 'E') {
|
|
break;
|
|
} else {
|
|
throw new FormatException($"Unexpected character '{c}' in '{text}'.");
|
|
}
|
|
}
|
|
|
|
if (!seenDigit) {
|
|
throw new FormatException($"No digits in '{text}'.");
|
|
}
|
|
|
|
int exponent = -fractionDigits;
|
|
if (index < text.Length) {
|
|
exponent += int.Parse(text[(index + 1)..], CultureInfo.InvariantCulture);
|
|
}
|
|
|
|
if (negative) {
|
|
mantissa = -mantissa;
|
|
}
|
|
|
|
return exponent >= 0
|
|
? (mantissa * BigInteger.Pow(10, exponent), BigInteger.One)
|
|
: (mantissa, BigInteger.Pow(10, -exponent));
|
|
}
|
|
|
|
/// <summary>Rounds an exact rational to N significant digits and formats them.</summary>
|
|
private static string formatRational(BigInteger numerator, BigInteger denominator, int digits) {
|
|
if (numerator.IsZero) {
|
|
return "0";
|
|
}
|
|
|
|
bool negative = numerator.Sign < 0;
|
|
numerator = BigInteger.Abs(numerator);
|
|
|
|
// Estimate of the decimal exponent of the leading digit from the bit lengths
|
|
// (log10(2) ~ 0.30103). The loop below corrects it when the estimate is off by one.
|
|
int exponent10 = (int)Math.Floor((numerator.GetBitLength() - denominator.GetBitLength()) * 0.30103);
|
|
string text;
|
|
|
|
while (true) {
|
|
int scale = digits - 1 - exponent10;
|
|
BigInteger scaledNumerator = numerator;
|
|
BigInteger scaledDenominator = denominator;
|
|
if (scale >= 0) {
|
|
scaledNumerator *= BigInteger.Pow(10, scale);
|
|
} else {
|
|
scaledDenominator *= BigInteger.Pow(10, -scale);
|
|
}
|
|
BigInteger rounded = roundToNearest(scaledNumerator, scaledDenominator);
|
|
text = rounded.ToString(CultureInfo.InvariantCulture);
|
|
if (text.Length == digits) {
|
|
break;
|
|
}
|
|
// Off by one either way (estimate too low, or rounding carried into a new digit).
|
|
exponent10 += text.Length - digits;
|
|
}
|
|
|
|
text = text.TrimEnd('0');
|
|
if (text.Length == 0) {
|
|
text = "0";
|
|
}
|
|
|
|
StringBuilder result = new(negative ? "-" : "");
|
|
if (exponent10 >= -5 && exponent10 < digits) {
|
|
// Positional notation for the range where it is readable.
|
|
if (exponent10 >= 0) {
|
|
text = text.PadRight(exponent10 + 1, '0');
|
|
result.Append(text[..(exponent10 + 1)]);
|
|
if (text.Length > exponent10 + 1) {
|
|
result.Append('.').Append(text[(exponent10 + 1)..]);
|
|
}
|
|
} else {
|
|
result.Append("0.").Append('0', -exponent10 - 1).Append(text);
|
|
}
|
|
} else {
|
|
result.Append(text[0]);
|
|
if (text.Length > 1) {
|
|
result.Append('.').Append(text[1..]);
|
|
}
|
|
result.Append('e').Append(exponent10.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
|
|
return result.ToString();
|
|
}
|
|
|
|
/// <summary>Integer nearest to numerator/denominator, ties away from zero (both positive).</summary>
|
|
private static BigInteger roundToNearest(BigInteger numerator, BigInteger denominator) {
|
|
BigInteger quotient = BigInteger.DivRem(numerator, denominator, out BigInteger remainder);
|
|
return (remainder << 1) >= denominator ? quotient + 1 : quotient;
|
|
}
|
|
}
|