API Documentation

Creates a BigFloat from a string representation. This is the most precise way to initialize a BigFloat.

Parameters:

• value - String representation of the number. Supports decimal, hexadecimal (0x), binary (0b), and scientific notation.

Example:

BigFloat a = new("123.456789012345678901234567890");
BigFloat b = new("1.23e+100");
BigFloat c = new("0xABC.DEF");
BigFloat d = new("0b1101.1011");

Creates a BigFloat from a double value.

Parameters:

• value - The double value to convert.

Note:

Due to the limitations of double precision, some precision may be lost. Use string constructor for exact values.

Creates a BigFloat from various integer types.

Standard arithmetic operators with full precision preservation.

Example:

BigFloat a = new("100.5");
BigFloat b = new("25.25");

BigFloat sum = a + b;  // 125.75
BigFloat diff = a - b; // 75.25
BigFloat prod = a * b; // 2537.625
BigFloat quot = a / b; // 3.9801980198...
BigFloat rem = a % b;  // 0.5

Comparison operators for BigFloat values.

Canonical .NET ordering and equality. Guard bits are rounded away so values like 2.5 and 2.5000 compare equal.

Example:

var values = new[] { new BigFloat("2.5"), new BigFloat("2.5000") };
bool canonical = values[0].Equals(values[1]); // true
values = values.OrderBy(v => v).ToArray();    // uses CompareTo for stable ordering

Alignment-aware comparisons that allow a configurable ULP tolerance. Ideal for convergence tests or scenarios where “close enough” is acceptable.

Example:

BigFloat expected = new("0.1");
BigFloat actual = BigFloat.SetPrecisionWithRound(expected, expected.Size - 4);
bool closeEnough = actual.EqualsUlp(expected, ulpTolerance: 1); // tolerance counts the last main-bit

CompareTotalOrder produces a deterministic ordering that includes guard bits (no canonicalization) and is useful for fast sorts. IsBitwiseEqual checks the exact mantissa, scale, and precision.

Example:

BigFloat a = new("2.5");
BigFloat b = new("2.5000");
bool identical = a.IsBitwiseEqual(b);        // false (different precision encodings)
int ordering = a.CompareTotalOrder(b);       // distinguishes encodings while staying stable

Use these helpers for all new code paths:

• AdjustAccuracy / SetAccuracy
• AdjustPrecision (delta-based resizing)
• SetPrecisionWithRound when shrinking with explicit rounding
• ZeroWithAccuracy / OneWithAccuracy for context-aware identity values

Grow or shrink the working accuracy while keeping the numeric value stable where possible. AdjustPrecision is the underlying implementation and remains available for direct control.

Parameters:

• deltaBits - Positive values append zero bits; negative values round then drop bits.
• accuracyBits - Target total accuracy (precision + scale).

Example:

BigFloat x = new("123.456");
BigFloat wider = BigFloat.AdjustAccuracy(x, 64);      // add headroom
BigFloat trimmed = BigFloat.AdjustPrecision(x, -32);  // round then drop bits
BigFloat target = BigFloat.SetAccuracy(x, 256);       // exact accuracy target

Rebuild the mantissa to a target size. SetPrecision pads or trims without rounding, but it is obsolete—use AdjustPrecision or SetPrecisionWithRound so the rounding behavior is explicit.

Example:

BigFloat value = new("0.1");
BigFloat rounded = BigFloat.SetPrecisionWithRound(value, 96);
BigFloat padded = BigFloat.SetPrecision(value, 256);

Older members are kept for compatibility and delegate to the accuracy-first helpers:

• SetPrecision → AdjustPrecision (or SetPrecisionWithRound when shrinking)
• ExtendPrecision → AdjustPrecision with a positive delta
• ReducePrecision → AdjustPrecision with a negative delta
• Zero/One → numeric literals or ZeroWithAccuracy/OneWithAccuracy for preserved context

Test whether the value can safely down-convert to built-in numeric types.

Example:

BigFloat big = new("1e+400");
if (!big.FitsInADouble())
{
    Console.WriteLine("Too large for double!");
}

Parses a string representation into a BigFloat.

Supported Formats:

• Decimal: "123.456", "1.23e+10"
• Hexadecimal: "0xABC.DEF"
• Binary: "0b1101.1011"
• Precision separator: "123.456|789"

Converts the BigFloat to a string representation.

Format Specifiers:

• "G" or default - General format with precision masking
• "E" - Scientific notation
• "X" - Hexadecimal
• "B" - Binary

Example:

BigFloat x = new("123.456789");
Console.WriteLine(x.ToString());    // "123.456789"
Console.WriteLine(x.ToString("E")); // "1.23456789E+2"
Console.WriteLine(x.ToString("X")); // "7B.74BC6A7EF9D"