Code Examples

using BigFloatLibrary;

// $10,000 at 5% annual rate, compounded daily for 30 years
BigFloat principal = new("10000.00000000000000");
BigFloat rate = new("0.05");
int compoundings = 365;
int years = 30;

BigFloat finalAmount = Calculate(principal, rate, compoundings, years);
BigFloat earned = finalAmount - principal;

Console.WriteLine($"Initial Investment: ${principal}");
Console.WriteLine($"Final Amount: ${finalAmount}");
Console.WriteLine($"Interest Earned: ${earned}");

// Compare with double precision (Correct is 44,812.29)
double doubleFinal = 10000 * Math.Pow(1 + 0.05 / 12, 12 * 30);
Console.WriteLine($"\nDouble precision: ${doubleFinal}");
Console.WriteLine($"Incorrect By: ${doubleFinal - (double)finalAmount}");

static BigFloat Calculate(
    BigFloat principal,
    BigFloat annualRate,
    int compoundingsPerYear,
    int years)
{
    // Formula: A = P(1 + r/n)^(nt)
    BigFloat ratePerPeriod = annualRate / compoundingsPerYear;
    BigFloat onePlusRate = BigFloat.OneWithAccuracy(ratePerPeriod.Precision) + ratePerPeriod;
    int totalPeriods = compoundingsPerYear * years;

    BigFloat amount = principal * BigFloat.Pow(onePlusRate, totalPeriods);
    return amount;
}

using BigFloatLibrary;

Dictionary exchangeRates = [];
CurrencyConverter converter = new();

// Set precise exchange rates
converter.SetExchangeRate("USD", "EUR", "0.92385647291038475");
converter.SetExchangeRate("EUR", "JPY", "157.38492018374659");
converter.SetExchangeRate("USD", "BTC", "0.000015823947562839");
converter.SetExchangeRate("USD", "JPY", "145.401077250238547");

// Convert $1,000,000 through multiple currencies
BigFloat usd = new("1000000.0000000000");
BigFloat eur = converter.Convert(usd, "USD", "EUR");
BigFloat jpy = converter.Convert(eur, "EUR", "JPY");
BigFloat backToUsd = converter.Convert(jpy, "JPY", "USD");

Console.WriteLine($"Original USD:     ${usd}");
Console.WriteLine($"Converted to EUR: €{eur}");
Console.WriteLine($"Converted to JPY: ¥{jpy}");
Console.WriteLine($"Back to USD:      ${backToUsd}");
Console.WriteLine($"Precision loss:   ${usd - backToUsd}");

class CurrencyConverter
{
    Dictionary exchangeRates = [];

    public void SetExchangeRate(string from, string to, string rate)
    {
        string key = $"{from}-{to}";
        exchangeRates[key] = new BigFloat(rate);
    }

    public BigFloat Convert(BigFloat amount, string from, string to)
    {
        string key = $"{from}-{to}";
        if (exchangeRates.TryGetValue(key, out BigFloat rate))
        {
            return amount * rate;
        }

        // Try reverse conversion
        string reverseKey = $"{to}-{from}";
        if (exchangeRates.TryGetValue(reverseKey, out BigFloat reverseRate))
        {
            return amount / reverseRate;
        }

        throw new InvalidOperationException($"No exchange rate found for {from} to {to}");
    }
}

using BigFloatLibrary;

var calc = new CircleCalculations(2000); // 2000 bits precision

// Earth's radius at equator (meters)
BigFloat earthRadius = BigFloat.SetPrecision(new BigFloat("6378137"), 2000);

Console.WriteLine("Earth Calculations (at equator):");
Console.WriteLine($"Radius: {earthRadius} meters");

BigFloat circumference = calc.Circumference(earthRadius);
Console.WriteLine($"Circumference: {circumference} meters");
Console.WriteLine($"             = {circumference / 1000} kilometers");

BigFloat area = calc.Area(earthRadius);
Console.WriteLine($"Surface area: {area} square meters");
Console.WriteLine($"            = {area / 1000000} square kilometers");

// Calculate arc length for 1 degree
BigFloat oneDegreeRadians = calc.pi / 180;
BigFloat arcLength = calc.ArcLength(earthRadius, oneDegreeRadians);
Console.WriteLine($"\nArc length of 1°: {arcLength} meters");
Console.WriteLine($"                = {arcLength / 1000} kilometers");

// Demonstrate precision vs double
double doubleCirc = 2 * Math.PI * 6378137;
Console.WriteLine($"\nDouble precision circumference: {doubleCirc}");
Console.WriteLine($"Difference: {circumference - (BigFloat)doubleCirc} meters");

public class CircleCalculations
{
    public readonly BigFloat pi;

    public CircleCalculations(int precisionBits = 1000)
    => pi = BigFloat.Constants.GetConstant("Pi", precisionBits);

    public BigFloat Area(BigFloat radius) => pi * radius * radius;

    public BigFloat Circumference(BigFloat radius) => 2 * pi * radius;

    public BigFloat ArcLength(BigFloat radius, BigFloat angleRadians)
    => radius * angleRadians;

    public static BigFloat SectorArea(BigFloat radius, BigFloat angleRadians)
    => radius * radius * angleRadians / 2;
}

using BigFloatLibrary;

var calc = new SphericalDistanceNoInverse(200);
BigFloat earthRadius = new("6371000.00"); // meters

// New York City
BigFloat nycLat = new ("40.712800");
BigFloat nycLon = new ("-74.006000");
// London
BigFloat londonLat = new ("51.507400");
BigFloat londonLon = new ("-0.12780000");

BigFloat distance = calc.CalculateDistance(
nycLat, nycLon, londonLat, londonLon, earthRadius);

Console.WriteLine("Great Circle Distance: NYC → London");
Console.WriteLine($"  NYC:    {nycLat}°N, {nycLon}°W");
Console.WriteLine($"  London: {londonLat}°N, {londonLon}°W");
Console.WriteLine($"  Distance = {distance} meters");
Console.WriteLine($"           = {distance / 1000} kilometers");
Console.WriteLine($"           = {distance / new BigFloat(1609.344)} miles");

class SphericalDistanceNoInverse(int precisionBits = 1000)
{
    private readonly BigFloat pi = BigFloat.Constants.GetConstant("Pi", precisionBits);
    readonly int precisionBits = precisionBits;

    // Convert degrees to radians
    BigFloat ToRadians(BigFloat degrees) => degrees * pi / BigFloat.SetPrecision(new BigFloat(180), precisionBits);

    /// 

    /// Solve for the central angle c (in radians) from haversine term a:
    ///     a = sin²(dlat/2) + cos(lat1)*cos(lat2)*sin²(dlon/2)
    /// so that:
    ///     cos(c) = 1 - 2a.
    /// We find c via Newton's method on f(c)=cos(c)-(1-2a)=0.
    ///
    
    BigFloat SolveCentralAngle(BigFloat a)
    {
        // target = 1 - 2a
        BigFloat one = BigFloat.OneWithAccuracy(precisionBits);
        BigFloat two = one * 2;
        BigFloat target = one - two * a;

        // initial guess: for small a, c≈2√a
        BigFloat c = two * BigFloat.Sqrt(a);

        // tolerance scaled to precision
        BigFloat tol = BigFloat.Pow(BigFloat.SetPrecision(BigFloat.SetPrecision(new BigFloat(10), precisionBits), precisionBits) , -((precisionBits / 3)));

        for (int iter = 0; iter < 50; iter++)
        {
            BigFloat f = BigFloat.Cos(c) - target;   // f(c)
            BigFloat df = -BigFloat.Sin(c);          // f'(c)

            if (df.IsZero)
            break;

            BigFloat delta = f / df;
            c -= delta;

            if (BigFloat.Abs(delta) < tol)
            break;
        }

        return c;
    }

    /// 

    /// Great‐circle distance using only Sin, Cos, Sqrt, +, −, ×, ÷.
    ///
    
    public BigFloat CalculateDistance(
    BigFloat lat1, BigFloat lon1,
    BigFloat lat2, BigFloat lon2,
    BigFloat radius)
    {
        // to radians
        lat1 = ToRadians(lat1);
        lon1 = ToRadians(lon1);
        lat2 = ToRadians(lat2);
        lon2 = ToRadians(lon2);

        // deltas
        BigFloat dlat = lat2 - lat1;
        BigFloat dlon = lon2 - lon1;
        BigFloat half = BigFloat.OneWithAccuracy(precisionBits) /2;

        // haversine 'a'
        BigFloat sin_dlat2 = BigFloat.Sin(dlat * half);
        BigFloat sin_dlon2 = BigFloat.Sin(dlon * half);
        BigFloat a = sin_dlat2 * sin_dlat2
        + BigFloat.Cos(lat1)
        * BigFloat.Cos(lat2)
        * (sin_dlon2 * sin_dlon2);

        // central angle c via solver
        BigFloat c = SolveCentralAngle(a);

        // arc length
        return radius * c;
    }
}