BigDecimal, BigInteger & Numeric Precision

// The classic demonstration
System.out.println(0.1 + 0.2);          // 0.30000000000000004  ❌
System.out.println(0.1 + 0.2 == 0.3);   // false  ❌

// Real financial damage:
double price = 0.10;
double quantity = 3;
System.out.println(price * quantity);     // 0.30000000000000004 — overcharge!

// With BigDecimal:
BigDecimal bdPrice = new BigDecimal("0.10");
BigDecimal bdQty = new BigDecimal("3");
System.out.println(bdPrice.multiply(bdQty));  // 0.30 — exact ✅

BigDecimal bd = new BigDecimal("123.45");
bd.unscaledValue();  // 12345 (BigInteger)
bd.scale();          // 2
bd.precision();      // 5

// Negative scale = large numbers
BigDecimal big = new BigDecimal("1.23E+10");  // 12300000000
big.unscaledValue(); // 123
big.scale();         // -8

// ❌ NEVER do this — captures the imprecise double representation
BigDecimal bad = new BigDecimal(0.1);
System.out.println(bad);  // 0.1000000000000000055511151231257827021181583404541015625

// ✅ Use String constructor — exact decimal representation
BigDecimal good = new BigDecimal("0.1");
System.out.println(good);  // 0.1

// ✅ Or use valueOf() for doubles — calls Double.toString() first, then String constructor
BigDecimal also_good = BigDecimal.valueOf(0.1);
System.out.println(also_good);  // 0.1

// ✅ Static constants for common values
BigDecimal.ZERO;  // 0
BigDecimal.ONE;   // 1
BigDecimal.TEN;   // 10

BigDecimal price = new BigDecimal("100.00");

// ❌ Common bug: ignoring return value
price.add(new BigDecimal("10.00"));  // result is DISCARDED!
System.out.println(price);            // still 100.00

// ✅ Correct: capture the return value
BigDecimal newPrice = price.add(new BigDecimal("10.00"));
System.out.println(newPrice);  // 110.00
System.out.println(price);     // 100.00 (original unchanged)

BigDecimal value = new BigDecimal("2.5");

value.setScale(0, RoundingMode.HALF_UP);    // 3
value.setScale(0, RoundingMode.HALF_EVEN);  // 2 (rounds to nearest EVEN)
value.setScale(0, RoundingMode.FLOOR);      // 2
value.setScale(0, RoundingMode.CEILING);    // 3

// Banker's rounding eliminates systematic bias in large datasets
// HALF_UP always rounds 0.5 up → cumulative positive bias
// HALF_EVEN rounds 0.5 to nearest even → bias cancels out over many operations

// MathContext = precision + RoundingMode
MathContext mc = new MathContext(4, RoundingMode.HALF_EVEN);

BigDecimal result = new BigDecimal("123.456789").round(mc);
System.out.println(result);  // 123.5 (4 significant digits)

// Pre-defined contexts
MathContext.DECIMAL32;   // 7 digits, HALF_EVEN (like float)
MathContext.DECIMAL64;   // 16 digits, HALF_EVEN (like double)
MathContext.DECIMAL128;  // 34 digits, HALF_EVEN (quad precision)
MathContext.UNLIMITED;   // unlimited precision, no rounding

// Use in operations
BigDecimal a = new BigDecimal("1");
BigDecimal b = new BigDecimal("3");
BigDecimal third = a.divide(b, mc);  // 0.3333 (4 significant digits)

BigDecimal a = new BigDecimal("2.0");
BigDecimal b = new BigDecimal("2.00");

// equals() checks BOTH value AND scale
a.equals(b);       // false! (scale 1 != scale 2)

// compareTo() checks numeric value only
a.compareTo(b);    // 0 (numerically equal) ✅

// This has HashMap implications!
Map<BigDecimal, String> map = new HashMap<>();
map.put(new BigDecimal("2.0"), "two");
map.get(new BigDecimal("2.00"));  // null! Different hashCode due to different scale

// Fix: use TreeMap (uses compareTo) or stripTrailingZeros()
Map<BigDecimal, String> treeMap = new TreeMap<>();
treeMap.put(new BigDecimal("2.0"), "two");
treeMap.get(new BigDecimal("2.00"));  // "two" ✅

// Or normalize:
a.stripTrailingZeros().equals(b.stripTrailingZeros());  // true ✅

// ❌ This THROWS ArithmeticException!
BigDecimal one = BigDecimal.ONE;
BigDecimal three = new BigDecimal("3");
one.divide(three);  // ArithmeticException: Non-terminating decimal expansion

// Why? 1/3 = 0.333333... (infinite), BigDecimal can't represent infinite decimals

// ✅ Always specify scale and RoundingMode for division
one.divide(three, 10, RoundingMode.HALF_EVEN);  // 0.3333333333

// ✅ Or use MathContext
one.divide(three, new MathContext(10, RoundingMode.HALF_EVEN));  // 0.3333333333

// Safe divisors (finite decimal expansion): powers of 2 and 5 only
// 1/2 = 0.5 ✅, 1/4 = 0.25 ✅, 1/5 = 0.2 ✅
// 1/3 ❌, 1/7 ❌, 1/6 ❌, 1/9 ❌

BigDecimal a = new BigDecimal("100.50");
BigDecimal b = new BigDecimal("23.75");

// Basic operations (all return new BigDecimal)
a.add(b);                          // 124.25
a.subtract(b);                     // 76.75
a.multiply(b);                     // 2386.8750
a.divide(b, 4, RoundingMode.HALF_EVEN);  // 4.2316

// Chaining operations
BigDecimal total = price
    .multiply(quantity)
    .add(tax)
    .setScale(2, RoundingMode.HALF_EVEN);

// Remainder and divideAndRemainder
BigDecimal[] result = a.divideAndRemainder(b);
// result[0] = quotient (4), result[1] = remainder (5.50)

// Power
a.pow(2);  // 10100.2500

// Absolute value, negate, signum
a.abs();       // 100.50
a.negate();    // -100.50
a.signum();    // 1 (positive), 0 (zero), -1 (negative)

// Scale manipulation
a.setScale(4, RoundingMode.HALF_EVEN);  // 100.5000
a.movePointLeft(2);   // 1.0050
a.movePointRight(2);  // 10050

// Alternative: store money as long cents (avoids BigDecimal overhead)
long priceInCents = 1999;  // $19.99
long taxInCents = 160;     // $1.60
long totalInCents = priceInCents + taxInCents;  // $21.59

// Convert for display
String formatted = String.format("$%d.%02d", totalInCents / 100, totalInCents % 100);

// When to use BigDecimal despite performance:
// - Variable decimal places (crypto: 8-18 decimals)
// - Regulatory requirement for exact arithmetic
// - Intermediate calculations need more precision than final result

// When long (max ~9.2 × 10^18) isn't enough
BigInteger factorial100 = BigInteger.ONE;
for (int i = 2; i <= 100; i++) {
    factorial100 = factorial100.multiply(BigInteger.valueOf(i));
}
// 100! = 93326215443944152681699238856266700490715968264381621468592963895...

// Common operations
BigInteger a = new BigInteger("123456789012345678901234567890");
BigInteger b = new BigInteger("987654321098765432109876543210");

a.add(b);
a.subtract(b);
a.multiply(b);
a.divide(b);          // integer division
a.mod(b);             // modulus
a.pow(10);            // a^10
a.gcd(b);             // greatest common divisor
a.isProbablePrime(10); // primality test (Miller-Rabin)
a.modPow(b, m);       // modular exponentiation (RSA!)

// Bit operations (useful for cryptography)
a.bitLength();        // number of bits
a.testBit(5);         // is bit 5 set?
a.setBit(10);         // set bit 10
a.and(b);             // bitwise AND
a.or(b);              // bitwise OR
a.xor(b);             // bitwise XOR
a.shiftLeft(3);       // << 3
a.shiftRight(3);      // >> 3

// Conversion
a.intValueExact();    // throws if overflow
a.longValueExact();   // throws if overflow
a.toByteArray();      // for serialization/crypto

public class TaxCalculator {
    private static final MathContext CALC_CONTEXT = 
        new MathContext(10, RoundingMode.HALF_EVEN);

    public BigDecimal calculateTotal(BigDecimal subtotal, BigDecimal taxRate) {
        // Tax rate as decimal: 8.25% = 0.0825
        BigDecimal tax = subtotal.multiply(taxRate, CALC_CONTEXT)
            .setScale(2, RoundingMode.HALF_UP);  // round tax to cents

        return subtotal.add(tax);
    }

    // Handling multiple items with different tax rates
    public BigDecimal calculateOrderTotal(List<LineItem> items) {
        BigDecimal total = BigDecimal.ZERO;

        for (LineItem item : items) {
            BigDecimal lineTotal = item.price()
                .multiply(BigDecimal.valueOf(item.quantity()))
                .setScale(2, RoundingMode.HALF_EVEN);

            BigDecimal lineTax = lineTotal
                .multiply(item.taxRate())
                .setScale(2, RoundingMode.HALF_UP);

            total = total.add(lineTotal).add(lineTax);
        }

        return total;
    }
}

public class CurrencyUtil {

    // Different currencies have different decimal places
    public static BigDecimal round(BigDecimal amount, Currency currency) {
        int decimals = currency.getDefaultFractionDigits();  // USD=2, JPY=0, BHD=3
        return amount.setScale(decimals, RoundingMode.HALF_EVEN);
    }

    // Split a bill evenly (handle remainder)
    public static List<BigDecimal> splitEvenly(BigDecimal total, int parts) {
        BigDecimal share = total.divide(BigDecimal.valueOf(parts), 
            2, RoundingMode.FLOOR);  // round down each share

        BigDecimal distributed = share.multiply(BigDecimal.valueOf(parts));
        BigDecimal remainder = total.subtract(distributed);  // leftover cents

        List<BigDecimal> shares = new ArrayList<>();
        for (int i = 0; i < parts; i++) {
            // Give remainder penny to first person(s)
            if (remainder.compareTo(BigDecimal.ZERO) > 0) {
                shares.add(share.add(new BigDecimal("0.01")));
                remainder = remainder.subtract(new BigDecimal("0.01"));
            } else {
                shares.add(share);
            }
        }
        return shares;
    }

    // Interest calculation
    public static BigDecimal compoundInterest(
            BigDecimal principal, BigDecimal annualRate, 
            int timesPerYear, int years) {
        // A = P(1 + r/n)^(nt)
        MathContext mc = new MathContext(20, RoundingMode.HALF_EVEN);

        BigDecimal ratePerPeriod = annualRate.divide(
            BigDecimal.valueOf(timesPerYear), mc);
        BigDecimal base = BigDecimal.ONE.add(ratePerPeriod);
        int totalPeriods = timesPerYear * years;

        BigDecimal amount = principal.multiply(base.pow(totalPeriods, mc), mc);
        return amount.setScale(2, RoundingMode.HALF_EVEN);
    }
}