Math & Numbers
BigDecimal Introduction
When calculating money, interest rates, or any value where 0.1 + 0.2 must equal exactly 0.3, floating-point errors are unacceptable. BigDecimal provides arbitrary-precision decimal arithmetic, representing decimal numbers exactly for financial and scientific calculations.
BigDecimal
An immutable class for arbitrary-precision decimal numbers that avoids the rounding errors inherent in float and double.
Creating BigDecimal
Create BigDecimal from strings (preferred) or primitive values.
Create.java
Replay: real traced execution (multi-file project)
// Create BigDecimal
import java.math.BigDecimal;
import java.math.BigInteger;
public class Create {
public static void main(String[] args) {
// From string (recommended)
BigDecimal bd1 = new BigDecimal("10.5");
System.out.println("From string: " + bd1);
// From double (avoid - precision issues)
BigDecimal bd2 = new BigDecimal(10.5);
System.out.println("From double (shows precision issues): " + bd2);
// Proper way from double
BigDecimal bd3 = BigDecimal.valueOf(10.5);
System.out.println("valueOf(double): " + bd3);
// From int
BigDecimal bd4 = new BigDecimal(42);
System.out.println("From int: " + bd4);
// From long
BigDecimal bd5 = BigDecimal.valueOf(123456789L);
System.out.println("From long: " + bd5);
// From BigInteger
BigInteger bi = new BigInteger("12345");
BigDecimal bd6 = new BigDecimal(bi);
System.out.println("From BigInteger: " + bd6);
// With scale
BigDecimal bd7 = new BigDecimal(bi, 2); // 123.45
System.out.println("From BigInteger with scale 2: " + bd7);
// Constants
System.out.println("\nConstants:");
System.out.println("ZERO: " + BigDecimal.ZERO);
System.out.println("ONE: " + BigDecimal.ONE);
System.out.println("TEN: " + BigDecimal.TEN);
// Very precise numbers
String precise = "3.14159265358979323846264338327950288419716939937510";
BigDecimal pi = new BigDecimal(precise);
System.out.println("\nPrecise pi: " + pi);
// Unscaled value and scale
System.out.println("\nUnscaled value and scale:");
BigDecimal num = new BigDecimal("123.45");
System.out.println("Number: " + num);
System.out.println("Unscaled value: " + num.unscaledValue());
System.out.println("Scale: " + num.scale());
System.out.println("Precision: " + num.precision());
// Scientific notation
System.out.println("\nScientific notation:");
BigDecimal sci1 = new BigDecimal("1.23E+5");
System.out.println("1.23E+5: " + sci1);
BigDecimal sci2 = new BigDecimal("4.56E-3");
System.out.println("4.56E-3: " + sci2);
// Convert to other types
System.out.println("\nConvert to other types:");
BigDecimal bd = new BigDecimal("42.75");
System.out.println("BigDecimal: " + bd);
System.out.println("intValue: " + bd.intValue());
System.out.println("longValue: " + bd.longValue());
System.out.println("floatValue: " + bd.floatValue());
System.out.println("doubleValue: " + bd.doubleValue());
System.out.println("toBigInteger: " + bd.toBigInteger());
// String representations
System.out.println("\nString representations:");
BigDecimal num2 = new BigDecimal("1234.5600");
System.out.println("toString: " + num2.toString());
System.out.println("toPlainString: " + num2.toPlainString());
System.out.println("toEngineeringString: " + num2.toEngineeringString());
// stripTrailingZeros
System.out.println("\nStrip trailing zeros:");
BigDecimal withZeros = new BigDecimal("123.4500");
System.out.println("Original: " + withZeros);
System.out.println("Stripped: " + withZeros.stripTrailingZeros());
// Compare double vs BigDecimal precision
System.out.println("\nDouble vs BigDecimal:");
double d1 = 0.1;
double d2 = 0.2;
System.out.println("Double: 0.1 + 0.2 = " + (d1 + d2));
BigDecimal bd8 = new BigDecimal("0.1");
BigDecimal bd9 = new BigDecimal("0.2");
System.out.println("BigDecimal: 0.1 + 0.2 = " + bd8.add(bd9));
}
//help h1
// new BigDecimal(String) - from string (recommended)
// BigDecimal.valueOf(double) - from double
// new BigDecimal(int/long) - from integer
// BigDecimal.ZERO, ONE, TEN - constants
// .scale() - decimal places
// .precision() - total digits
// .unscaledValue() - value without decimal point
// Always use String constructor for exact values
//end
}
bd1 ← 10.5, bd2 ← 10.5, bd3 ← 10.5, bd4 ← 42, bd5 ← 123456789
6public class Create {7 public static void main(String[] args) {8 // From string (recommended)9 BigDecimal bd1→ 10.5 = new BigDecimal("10.5");10 System.out.println("From string: " + bd110.5);1112 // From double (avoid - precision issues)13 BigDecimal bd2→ 10.5 = new BigDecimal(10.5);14 System.out.println("From double (shows precision issues): " + bd210.5);1516 // Proper way from double17 BigDecimal bd3→ 10.5 = BigDecimal.valueOf(10.5);18 System.out.println("valueOf(double): " + bd310.5);1920 // From int21 BigDecimal bd4→ 42 = new BigDecimal(42);22 System.out.println("From int: " + bd442);2324 // From long25 BigDecimal bd5→ 123456789 = BigDecimal.valueOf(123456789L);26 System.out.println("From long: " + bd5123456789);2728 // From BigInteger29 BigInteger bi→ 12345 = new BigInteger("12345");30 BigDecimal bd6→ 12345 = new BigDecimal(bi);31 System.out.println("From BigInteger: " + bd612345);3233 // With scale34 BigDecimal bd7→ 123.45 = new BigDecimal(bi, 2); // 123.4535 System.out.println("From BigInteger with scale 2: " + bd7123.45);3637 // Constants38 System.out.println("\nConstants:");39 System.out.println("ZERO: " + BigDecimal.ZERO);40 System.out.println("ONE: " + BigDecimal.ONE);41 System.out.println("TEN: " + BigDecimal.TEN);4243 // Very precise numbers44 String precise→ 3.14159265358979323846264338327950288419716939937510 = "3.14159265358979323846264338327950288419716939937510";45 BigDecimal pi→ 3.14159265358979323846264338327950288419716939937510 = new BigDecimal(precise);46 System.out.println("\nPrecise pi: " + pi3.14159265358979323846264338327950288419716939937510);4748 // Unscaled value and scale49 System.out.println("\nUnscaled value and scale:");50 BigDecimal num→ 123.45 = new BigDecimal("123.45");51 System.out.println("Number: " + num123.45);52 System.out.println("Unscaled value: " + num.unscaledValue());53 System.out.println("Scale: " + num.scale());54 System.out.println("Precision: " + num.precision());5556 // Scientific notation57 System.out.println("\nScientific notation:");58 BigDecimal sci1→ 1.23E+5 = new BigDecimal("1.23E+5");59 System.out.println("1.23E+5: " + sci11.23E+5);60 61 BigDecimal sci2→ 0.00456 = new BigDecimal("4.56E-3");62 System.out.println("4.56E-3: " + sci20.00456);6364 // Convert to other types65 System.out.println("\nConvert to other types:");66 BigDecimal bd→ 42.75 = new BigDecimal("42.75");67 System.out.println("BigDecimal: " + bd42.75);68 System.out.println("intValue: " + bd.intValue());69 System.out.println("longValue: " + bd.longValue());70 System.out.println("floatValue: " + bd.floatValue());71 System.out.println("doubleValue: " + bd.doubleValue());72 System.out.println("toBigInteger: " + bd.toBigInteger());7374 // String representations75 System.out.println("\nString representations:");76 BigDecimal num2→ 1234.5600 = new BigDecimal("1234.5600");77 System.out.println("toString: " + num2.toString());78 System.out.println("toPlainString: " + num2.toPlainString());79 System.out.println("toEngineeringString: " + num2.toEngineeringString());8081 // stripTrailingZeros82 System.out.println("\nStrip trailing zeros:");83 BigDecimal withZeros→ 123.4500 = new BigDecimal("123.4500");84 System.out.println("Original: " + withZeros123.4500);85 System.out.println("Stripped: " + withZeros.stripTrailingZeros());8687 // Compare double vs BigDecimal precision88 System.out.println("\nDouble vs BigDecimal:");89 double d1→ 0.1 = 0.1;90 double d2→ 0.2 = 0.2;91 System.out.println("Double: 0.1 + 0.2 = " + (d10.1 + d20.2));92 93 BigDecimal bd8→ 0.1 = new BigDecimal("0.1");94 BigDecimal bd9→ 0.2 = new BigDecimal("0.2");95 System.out.println("BigDecimal: 0.1 + 0.2 = " + bd8.add(bd90.2));96 }outputFrom string: 10.5 From double (shows precision issues): 10.5 valueOf(double): 10.5 From int: 42 From long: 123456789 From BigInteger: 12345 From BigInteger with scale 2: 123.45 Constants: ZERO: 0 ONE: 1 TEN: 10 Precise pi: 3.14159265358979323846264338327950288419716939937510 Unscaled value and scale: Number: 123.45 Unscaled value: 12345 Scale: 2 Precision: 5 Scientific notation: 1.23E+5: 1.23E+5 4.56E-3: 0.00456 Convert to other types: BigDecimal: 42.75 intValue: 42 longValue: 42 floatValue: 42.75 doubleValue: 42.75 toBigInteger: 42 String representations: toString: 1234.5600 toPlainString: 1234.5600 toEngineeringString: 1234.5600 Strip trailing zeros: Original: 123.4500 Stripped: 123.45 Double vs BigDecimal: Double: 0.1 + 0.2 = 0.30000000000000004 BigDecimal: 0.1 + 0.2 = 0.3
String constructor
Always use new BigDecimal("0.1") instead of new BigDecimal(0.1) to avoid inheriting float/double imprecision.
Arithmetic Operations
Perform calculations with precise decimal arithmetic.
Arithmetic.java
Replay: real traced execution (multi-file project)
// Arithmetic with MathContext
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
public class Arithmetic {
public static void main(String[] args) {
BigDecimal a = new BigDecimal("10.5");
BigDecimal b = new BigDecimal("3.25");
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println();
// Addition
System.out.println("Addition:");
BigDecimal sum = a.add(b);
System.out.println("a + b = " + sum);
// Subtraction
System.out.println("\nSubtraction:");
BigDecimal diff = a.subtract(b);
System.out.println("a - b = " + diff);
// Multiplication
System.out.println("\nMultiplication:");
BigDecimal product = a.multiply(b);
System.out.println("a * b = " + product);
// Division (requires scale and rounding)
System.out.println("\nDivision:");
BigDecimal quotient = a.divide(b, 2, RoundingMode.HALF_UP);
System.out.println("a / b = " + quotient + " (2 decimals, HALF_UP)");
// Division with MathContext
MathContext mc = new MathContext(10, RoundingMode.HALF_UP);
BigDecimal quot2 = a.divide(b, mc);
System.out.println("a / b = " + quot2 + " (10 sig figs, HALF_UP)");
// Remainder
System.out.println("\nRemainder:");
BigDecimal remainder = a.remainder(b);
System.out.println("a % b = " + remainder);
// divideAndRemainder
System.out.println("\ndivideAndRemainder:");
BigDecimal[] divResult = a.divideAndRemainder(b);
System.out.println("Quotient: " + divResult[0]);
System.out.println("Remainder: " + divResult[1]);
// Power
System.out.println("\nPower:");
BigDecimal base = new BigDecimal("2");
BigDecimal power = base.pow(10);
System.out.println("2^10 = " + power);
// Negate
System.out.println("\nNegate:");
BigDecimal neg = a.negate();
System.out.println("-a = " + neg);
// Absolute value
System.out.println("\nAbsolute value:");
BigDecimal negative = new BigDecimal("-42.5");
System.out.println("abs(-42.5) = " + negative.abs());
// Plus (applies MathContext)
System.out.println("\nPlus (applies MathContext):");
MathContext mc2 = new MathContext(3, RoundingMode.HALF_UP);
BigDecimal val = new BigDecimal("12.3456");
System.out.println("Original: " + val);
System.out.println("With MC(3): " + val.plus(mc2));
// Chaining operations
System.out.println("\nChaining:");
BigDecimal result = new BigDecimal("5")
.multiply(new BigDecimal("3"))
.add(new BigDecimal("10"))
.subtract(new BigDecimal("2"));
System.out.println("5 * 3 + 10 - 2 = " + result);
// Divide with exact division
System.out.println("\nExact division:");
try {
BigDecimal x = new BigDecimal("10");
BigDecimal y = new BigDecimal("2");
BigDecimal exactQuot = x.divide(y); // No rounding needed
System.out.println("10 / 2 = " + exactQuot);
} catch (ArithmeticException e) {
System.out.println("Cannot divide exactly: " + e.getMessage());
}
// Non-terminating division requires rounding
System.out.println("\nNon-terminating division:");
try {
BigDecimal x = new BigDecimal("1");
BigDecimal y = new BigDecimal("3");
BigDecimal inexact = x.divide(y); // Will throw exception
} catch (ArithmeticException e) {
System.out.println("Error: " + e.getMessage());
BigDecimal x = new BigDecimal("1");
BigDecimal y = new BigDecimal("3");
BigDecimal rounded = x.divide(y, 10, RoundingMode.HALF_UP);
System.out.println("1 / 3 with rounding: " + rounded);
}
// MathContext in operations
System.out.println("\nMathContext in operations:");
MathContext mc10 = new MathContext(10);
BigDecimal a2 = new BigDecimal("1.234567890123");
BigDecimal b2 = new BigDecimal("2.345678901234");
BigDecimal sum2 = a2.add(b2, mc10);
BigDecimal prod2 = a2.multiply(b2, mc10);
System.out.println("Sum (10 sig figs): " + sum2);
System.out.println("Product (10 sig figs): " + prod2);
// Compound interest example
System.out.println("\nCompound interest:");
BigDecimal principal = new BigDecimal("1000");
BigDecimal rate = new BigDecimal("0.05");
int years = 10;
BigDecimal amount = principal.multiply(
BigDecimal.ONE.add(rate).pow(years)
);
amount = amount.setScale(2, RoundingMode.HALF_UP);
System.out.println("Principal: $" + principal);
System.out.println("Rate: " + rate.multiply(new BigDecimal("100")) + "%");
System.out.println("Years: " + years);
System.out.println("Amount: $" + amount);
System.out.println("Interest: $" + amount.subtract(principal));
}
//help h1
// .add(other) - addition
// .subtract(other) - subtraction
// .multiply(other) - multiplication
// .divide(other, scale, roundingMode) - division
// .divide(other, MathContext) - division with context
// .remainder(other) - modulo
// .pow(n) - power
// .negate() - negation
// .abs() - absolute value
// Division always requires scale/rounding or MathContext
// Immutable: operations return new BigDecimal
//end
}
a ← 10.5, b ← 3.25, sum ← 13.75, diff ← 7.25, product ← 34.125
7public class Arithmetic {8 public static void main(String[] args) {9 BigDecimal a→ 10.5 = new BigDecimal("10.5");10 BigDecimal b→ 3.25 = new BigDecimal("3.25");11 12 System.out.println("a = " + a10.5);13 System.out.println("b = " + b3.25);14 System.out.println();1516 // Addition17 System.out.println("Addition:");18 BigDecimal sum→ 13.75 = a.add(b3.25);19 System.out.println("a + b = " + sum13.75);2021 // Subtraction22 System.out.println("\nSubtraction:");23 BigDecimal diff→ 7.25 = a.subtract(b3.25);24 System.out.println("a - b = " + diff7.25);2526 // Multiplication27 System.out.println("\nMultiplication:");28 BigDecimal product→ 34.125 = a.multiply(b3.25);29 System.out.println("a * b = " + product34.125);3031 // Division (requires scale and rounding)32 System.out.println("\nDivision:");33 BigDecimal quotient→ 3.23 = a.divide(b3.25, 2, RoundingMode.HALF_UP);34 System.out.println("a / b = " + quotient3.23 + " (2 decimals, HALF_UP)");3536 // Division with MathContext37 MathContext mc→ precision=10 roundingMode=HALF_UP = new MathContext(10, RoundingMode.HALF_UP);38 BigDecimal quot2→ 3.230769231 = a.divide(b3.25, mcprecision=10 roundingMode=HALF_UP);39 System.out.println("a / b = " + quot23.230769231 + " (10 sig figs, HALF_UP)");4041 // Remainder42 System.out.println("\nRemainder:");43 BigDecimal remainder→ 0.75 = a.remainder(b3.25);44 System.out.println("a % b = " + remainder0.75);4546 // divideAndRemainder47 System.out.println("\ndivideAndRemainder:");48 BigDecimal[] divResult = a.divideAndRemainder(b3.25);49 System.out.println("Quotient: " + divResult[0]3);50 System.out.println("Remainder: " + divResult[1]0.75);5152 // Power53 System.out.println("\nPower:");54 BigDecimal base→ 2 = new BigDecimal("2");55 BigDecimal power→ 1024 = base.pow(10);56 System.out.println("2^10 = " + power1024);5758 // Negate59 System.out.println("\nNegate:");60 BigDecimal neg→ -10.5 = a.negate();61 System.out.println("-a = " + neg-10.5);6263 // Absolute value64 System.out.println("\nAbsolute value:");65 BigDecimal negative→ -42.5 = new BigDecimal("-42.5");66 System.out.println("abs(-42.5) = " + negative.abs());6768 // Plus (applies MathContext)69 System.out.println("\nPlus (applies MathContext):");70 MathContext mc2→ precision=3 roundingMode=HALF_UP = new MathContext(3, RoundingMode.HALF_UP);71 BigDecimal val→ 12.3456 = new BigDecimal("12.3456");72 System.out.println("Original: " + val12.3456);73 System.out.println("With MC(3): " + val.plus(mc2precision=3 roundingMode=HALF_UP));7475 // Chaining operations76 System.out.println("\nChaining:");77 BigDecimal result→ 23 = new BigDecimal("5")78 .multiply(new BigDecimal("3"))79 .add(new BigDecimal("10"))80 .subtract(new BigDecimal("2"));81 System.out.println("5 * 3 + 10 - 2 = " + result23);8283 // Divide with exact division84 System.out.println("\nExact division:");85 try {outputa = 10.5 b = 3.25 Addition: a + b = 13.75 Subtraction: a - b = 7.25 Multiplication: a * b = 34.125 Division: a / b = 3.23 (2 decimals, HALF_UP) a / b = 3.230769231 (10 sig figs, HALF_UP) Remainder: a % b = 0.75 divideAndRemainder: Quotient: 3 Remainder: 0.75 Power: 2^10 = 1024 Negate: -a = -10.5 Absolute value: abs(-42.5) = 42.5 Plus (applies MathContext): Original: 12.3456 With MC(3): 12.3 Chaining: 5 * 3 + 10 - 2 = 23 Exact division:x ← 10, y ← 2, exactQuot ← 5
84System.out.println("\nExact division:");85try {86 BigDecimal x→ 10 = new BigDecimal("10");87 BigDecimal y→ 2 = new BigDecimal("2");88 BigDecimal exactQuot→ 5 = x.divide(y2); // No rounding needed89 System.out.println("10 / 2 = " + exactQuot5);90} catch (ArithmeticException e) {output10 / 2 = 5System.out.println(" Non-terminating division:");
94// Non-terminating division requires rounding95System.out.println("\nNon-terminating division:");96try {output Non-terminating division:x ← 1, y ← 3
95System.out.println("\nNon-terminating division:");96try {97 BigDecimal x→ 1 = new BigDecimal("1");98 BigDecimal y→ 3 = new BigDecimal("3");99 BigDecimal inexact = x.divide(y3); // Will throw exception100} catch (ArithmeticException e) {x ← 1, y ← 3, rounded ← 0.3333333333
99 BigDecimal inexact = x.divide(y); // Will throw exception100} catch (ArithmeticException ejava.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.) {101 System.out.println("Error: " + e.getMessage());102 BigDecimal x→ 1 = new BigDecimal("1");103 BigDecimal y→ 3 = new BigDecimal("3");104 BigDecimal rounded→ 0.3333333333 = x.divide(y3, 10, RoundingMode.HALF_UP);105 System.out.println("1 / 3 with rounding: " + rounded0.3333333333);106}outputError: Non-terminating decimal expansion; no exact representable decimal result. 1 / 3 with rounding: 0.3333333333mc10 ← precision=10 roundingMode=HALF_UP, a2 ← 1.234567890123
108 // MathContext in operations109 System.out.println("\nMathContext in operations:");110 MathContext mc10→ precision=10 roundingMode=HALF_UP = new MathContext(10);111 BigDecimal a2→ 1.234567890123 = new BigDecimal("1.234567890123");112 BigDecimal b2→ 2.345678901234 = new BigDecimal("2.345678901234");113 114 BigDecimal sum2→ 3.580246791 = a2.add(b22.345678901234, mc10precision=10 roundingMode=HALF_UP);115 BigDecimal prod2→ 2.895899852 = a2.multiply(b22.345678901234, mc10precision=10 roundingMode=HALF_UP);116 117 System.out.println("Sum (10 sig figs): " + sum23.580246791);118 System.out.println("Product (10 sig figs): " + prod22.895899852);119120 // Compound interest example121 System.out.println("\nCompound interest:");122 BigDecimal principal→ 1000 = new BigDecimal("1000");123 BigDecimal rate→ 0.05 = new BigDecimal("0.05");124 int years→ 10 = 10;125 126 BigDecimal amount→ 1628.89462677744140625000 = principal.multiply(127 BigDecimal.ONE.add(rate0.05).pow(years10)128 );129 amount→ 1628.89 = amount.setScale(2, RoundingMode.HALF_UP);130 131 System.out.println("Principal: $" + principal1000);132 System.out.println("Rate: " + rate.multiply(new BigDecimal("100")) + "%");133 System.out.println("Years: " + years10);134 System.out.println("Amount: $" + amount1628.89);135 System.out.println("Interest: $" + amount.subtract(principal1000));136}output MathContext in operations: Sum (10 sig figs): 3.580246791 Product (10 sig figs): 2.895899852 Compound interest: Principal: $1000 Rate: 5.00% Years: 10 Amount: $1628.89 Interest: $628.89
Scale and Precision
Control the number of decimal places and significant digits.
Scale.java
Replay: real traced execution (multi-file project)
// Scale and precision
import java.math.BigDecimal;
import java.math.RoundingMode;
public class Scale {
public static void main(String[] args) {
// Scale: number of digits to the right of decimal point
// Precision: total number of significant digits
BigDecimal num1 = new BigDecimal("123.45");
System.out.println("Number: " + num1);
System.out.println("Scale: " + num1.scale());
System.out.println("Precision: " + num1.precision());
System.out.println();
BigDecimal num2 = new BigDecimal("0.0012");
System.out.println("Number: " + num2);
System.out.println("Scale: " + num2.scale());
System.out.println("Precision: " + num2.precision());
System.out.println();
// setScale
System.out.println("setScale:");
String valueText = "12.3456";
BigDecimal value = new BigDecimal(valueText);
System.out.println("Original: " + value);
BigDecimal rounded2 = value.setScale(2, RoundingMode.HALF_UP);
System.out.println("2 decimals (HALF_UP): " + rounded2);
BigDecimal rounded0 = value.setScale(0, RoundingMode.HALF_UP);
System.out.println("0 decimals (HALF_UP): " + rounded0);
BigDecimal rounded4 = value.setScale(4, RoundingMode.HALF_UP);
System.out.println("4 decimals (HALF_UP): " + rounded4);
// Increase scale (add trailing zeros)
System.out.println("\nIncrease scale:");
BigDecimal val = new BigDecimal("10.5");
System.out.println("Original: " + val + " (scale: " + val.scale() + ")");
BigDecimal increased = val.setScale(4, RoundingMode.UNNECESSARY);
System.out.println("Scale 4: " + increased + " (scale: " + increased.scale() + ")");
// Decrease scale (requires rounding)
System.out.println("\nDecrease scale:");
BigDecimal val2 = new BigDecimal("10.5678");
System.out.println("Original: " + val2 + " (scale: " + val2.scale() + ")");
BigDecimal decreased = val2.setScale(2, RoundingMode.HALF_UP);
System.out.println("Scale 2: " + decreased + " (scale: " + decreased.scale() + ")");
// stripTrailingZeros
System.out.println("\nstripTrailingZeros:");
BigDecimal withZeros = new BigDecimal("123.4500");
System.out.println("Original: " + withZeros + " (scale: " + withZeros.scale() + ")");
BigDecimal stripped = withZeros.stripTrailingZeros();
System.out.println("Stripped: " + stripped + " (scale: " + stripped.scale() + ")");
// movePointLeft and movePointRight
System.out.println("\nmovePointLeft and movePointRight:");
BigDecimal num = new BigDecimal("123.45");
System.out.println("Original: " + num);
System.out.println("Move point left 2: " + num.movePointLeft(2));
System.out.println("Move point right 2: " + num.movePointRight(2));
// scaleByPowerOfTen
System.out.println("\nscaleByPowerOfTen:");
BigDecimal base = new BigDecimal("1.5");
System.out.println("Original: " + base);
System.out.println("Scale by 10^2: " + base.scaleByPowerOfTen(2));
System.out.println("Scale by 10^-2: " + base.scaleByPowerOfTen(-2));
// Different rounding modes
System.out.println("\nRounding modes:");
BigDecimal roundVal = new BigDecimal("2.5");
System.out.println("Value: " + roundVal);
System.out.println("CEILING: " + roundVal.setScale(0, RoundingMode.CEILING));
System.out.println("FLOOR: " + roundVal.setScale(0, RoundingMode.FLOOR));
System.out.println("UP: " + roundVal.setScale(0, RoundingMode.UP));
System.out.println("DOWN: " + roundVal.setScale(0, RoundingMode.DOWN));
System.out.println("HALF_UP: " + roundVal.setScale(0, RoundingMode.HALF_UP));
System.out.println("HALF_DOWN: " + roundVal.setScale(0, RoundingMode.HALF_DOWN));
System.out.println("HALF_EVEN: " + roundVal.setScale(0, RoundingMode.HALF_EVEN));
// Negative values
System.out.println("\nRounding negative values:");
BigDecimal negVal = new BigDecimal("-2.5");
System.out.println("Value: " + negVal);
System.out.println("HALF_UP: " + negVal.setScale(0, RoundingMode.HALF_UP));
System.out.println("HALF_EVEN: " + negVal.setScale(0, RoundingMode.HALF_EVEN));
// Financial rounding (2 decimals)
System.out.println("\nFinancial rounding:");
BigDecimal[] prices = {
new BigDecimal("19.994"),
new BigDecimal("19.995"),
new BigDecimal("19.996")
};
for (BigDecimal price : prices) {
BigDecimal rounded = price.setScale(2, RoundingMode.HALF_UP);
System.out.println("$" + price + " -> $" + rounded);
}
// Precision control
System.out.println("\nPrecision:");
BigDecimal precise = new BigDecimal("123.456789");
System.out.println("Original: " + precise);
System.out.println("Precision: " + precise.precision());
System.out.println("Scale: " + precise.scale());
// ulp (unit in last place)
System.out.println("\nulp:");
BigDecimal val3 = new BigDecimal("1.5");
System.out.println("Value: " + val3);
System.out.println("ulp: " + val3.ulp());
}
//help h1
// .scale() - get decimal places
// .precision() - get total significant digits
// .setScale(n, roundingMode) - set decimal places
// .stripTrailingZeros() - remove trailing zeros
// .movePointLeft(n), .movePointRight(n)
// .scaleByPowerOfTen(n) - multiply by 10^n
// RoundingMode: HALF_UP, HALF_EVEN, CEILING, FLOOR, etc.
// Use setScale(2, HALF_UP) for currency
//end
}
// Scale and precision
import java.math.BigDecimal;
import java.math.RoundingMode;
public class Scale {
public static void main(String[] args) {
// Scale: number of digits to the right of decimal point
// Precision: total number of significant digits
BigDecimal num1 = new BigDecimal("123.45");
System.out.println("Number: " + num1);
System.out.println("Scale: " + num1.scale());
System.out.println("Precision: " + num1.precision());
System.out.println();
BigDecimal num2 = new BigDecimal("0.0012");
System.out.println("Number: " + num2);
System.out.println("Scale: " + num2.scale());
System.out.println("Precision: " + num2.precision());
System.out.println();
// setScale
System.out.println("setScale:");
String valueText = "9.995";
BigDecimal value = new BigDecimal(valueText);
System.out.println("Original: " + value);
BigDecimal rounded2 = value.setScale(2, RoundingMode.HALF_UP);
System.out.println("2 decimals (HALF_UP): " + rounded2);
BigDecimal rounded0 = value.setScale(0, RoundingMode.HALF_UP);
System.out.println("0 decimals (HALF_UP): " + rounded0);
BigDecimal rounded4 = value.setScale(4, RoundingMode.HALF_UP);
System.out.println("4 decimals (HALF_UP): " + rounded4);
// Increase scale (add trailing zeros)
System.out.println("\nIncrease scale:");
BigDecimal val = new BigDecimal("10.5");
System.out.println("Original: " + val + " (scale: " + val.scale() + ")");
BigDecimal increased = val.setScale(4, RoundingMode.UNNECESSARY);
System.out.println("Scale 4: " + increased + " (scale: " + increased.scale() + ")");
// Decrease scale (requires rounding)
System.out.println("\nDecrease scale:");
BigDecimal val2 = new BigDecimal("10.5678");
System.out.println("Original: " + val2 + " (scale: " + val2.scale() + ")");
BigDecimal decreased = val2.setScale(2, RoundingMode.HALF_UP);
System.out.println("Scale 2: " + decreased + " (scale: " + decreased.scale() + ")");
// stripTrailingZeros
System.out.println("\nstripTrailingZeros:");
BigDecimal withZeros = new BigDecimal("123.4500");
System.out.println("Original: " + withZeros + " (scale: " + withZeros.scale() + ")");
BigDecimal stripped = withZeros.stripTrailingZeros();
System.out.println("Stripped: " + stripped + " (scale: " + stripped.scale() + ")");
// movePointLeft and movePointRight
System.out.println("\nmovePointLeft and movePointRight:");
BigDecimal num = new BigDecimal("123.45");
System.out.println("Original: " + num);
System.out.println("Move point left 2: " + num.movePointLeft(2));
System.out.println("Move point right 2: " + num.movePointRight(2));
// scaleByPowerOfTen
System.out.println("\nscaleByPowerOfTen:");
BigDecimal base = new BigDecimal("1.5");
System.out.println("Original: " + base);
System.out.println("Scale by 10^2: " + base.scaleByPowerOfTen(2));
System.out.println("Scale by 10^-2: " + base.scaleByPowerOfTen(-2));
// Different rounding modes
System.out.println("\nRounding modes:");
BigDecimal roundVal = new BigDecimal("2.5");
System.out.println("Value: " + roundVal);
System.out.println("CEILING: " + roundVal.setScale(0, RoundingMode.CEILING));
System.out.println("FLOOR: " + roundVal.setScale(0, RoundingMode.FLOOR));
System.out.println("UP: " + roundVal.setScale(0, RoundingMode.UP));
System.out.println("DOWN: " + roundVal.setScale(0, RoundingMode.DOWN));
System.out.println("HALF_UP: " + roundVal.setScale(0, RoundingMode.HALF_UP));
System.out.println("HALF_DOWN: " + roundVal.setScale(0, RoundingMode.HALF_DOWN));
System.out.println("HALF_EVEN: " + roundVal.setScale(0, RoundingMode.HALF_EVEN));
// Negative values
System.out.println("\nRounding negative values:");
BigDecimal negVal = new BigDecimal("-2.5");
System.out.println("Value: " + negVal);
System.out.println("HALF_UP: " + negVal.setScale(0, RoundingMode.HALF_UP));
System.out.println("HALF_EVEN: " + negVal.setScale(0, RoundingMode.HALF_EVEN));
// Financial rounding (2 decimals)
System.out.println("\nFinancial rounding:");
BigDecimal[] prices = {
new BigDecimal("19.994"),
new BigDecimal("19.995"),
new BigDecimal("19.996")
};
for (BigDecimal price : prices) {
BigDecimal rounded = price.setScale(2, RoundingMode.HALF_UP);
System.out.println("$" + price + " -> $" + rounded);
}
// Precision control
System.out.println("\nPrecision:");
BigDecimal precise = new BigDecimal("123.456789");
System.out.println("Original: " + precise);
System.out.println("Precision: " + precise.precision());
System.out.println("Scale: " + precise.scale());
// ulp (unit in last place)
System.out.println("\nulp:");
BigDecimal val3 = new BigDecimal("1.5");
System.out.println("Value: " + val3);
System.out.println("ulp: " + val3.ulp());
}
//help h1
// .scale() - get decimal places
// .precision() - get total significant digits
// .setScale(n, roundingMode) - set decimal places
// .stripTrailingZeros() - remove trailing zeros
// .movePointLeft(n), .movePointRight(n)
// .scaleByPowerOfTen(n) - multiply by 10^n
// RoundingMode: HALF_UP, HALF_EVEN, CEILING, FLOOR, etc.
// Use setScale(2, HALF_UP) for currency
//end
}
// Scale and precision
import java.math.BigDecimal;
import java.math.RoundingMode;
public class Scale {
public static void main(String[] args) {
// Scale: number of digits to the right of decimal point
// Precision: total number of significant digits
BigDecimal num1 = new BigDecimal("123.45");
System.out.println("Number: " + num1);
System.out.println("Scale: " + num1.scale());
System.out.println("Precision: " + num1.precision());
System.out.println();
BigDecimal num2 = new BigDecimal("0.0012");
System.out.println("Number: " + num2);
System.out.println("Scale: " + num2.scale());
System.out.println("Precision: " + num2.precision());
System.out.println();
// setScale
System.out.println("setScale:");
String valueText = "2.500";
BigDecimal value = new BigDecimal(valueText);
System.out.println("Original: " + value);
BigDecimal rounded2 = value.setScale(2, RoundingMode.HALF_UP);
System.out.println("2 decimals (HALF_UP): " + rounded2);
BigDecimal rounded0 = value.setScale(0, RoundingMode.HALF_UP);
System.out.println("0 decimals (HALF_UP): " + rounded0);
BigDecimal rounded4 = value.setScale(4, RoundingMode.HALF_UP);
System.out.println("4 decimals (HALF_UP): " + rounded4);
// Increase scale (add trailing zeros)
System.out.println("\nIncrease scale:");
BigDecimal val = new BigDecimal("10.5");
System.out.println("Original: " + val + " (scale: " + val.scale() + ")");
BigDecimal increased = val.setScale(4, RoundingMode.UNNECESSARY);
System.out.println("Scale 4: " + increased + " (scale: " + increased.scale() + ")");
// Decrease scale (requires rounding)
System.out.println("\nDecrease scale:");
BigDecimal val2 = new BigDecimal("10.5678");
System.out.println("Original: " + val2 + " (scale: " + val2.scale() + ")");
BigDecimal decreased = val2.setScale(2, RoundingMode.HALF_UP);
System.out.println("Scale 2: " + decreased + " (scale: " + decreased.scale() + ")");
// stripTrailingZeros
System.out.println("\nstripTrailingZeros:");
BigDecimal withZeros = new BigDecimal("123.4500");
System.out.println("Original: " + withZeros + " (scale: " + withZeros.scale() + ")");
BigDecimal stripped = withZeros.stripTrailingZeros();
System.out.println("Stripped: " + stripped + " (scale: " + stripped.scale() + ")");
// movePointLeft and movePointRight
System.out.println("\nmovePointLeft and movePointRight:");
BigDecimal num = new BigDecimal("123.45");
System.out.println("Original: " + num);
System.out.println("Move point left 2: " + num.movePointLeft(2));
System.out.println("Move point right 2: " + num.movePointRight(2));
// scaleByPowerOfTen
System.out.println("\nscaleByPowerOfTen:");
BigDecimal base = new BigDecimal("1.5");
System.out.println("Original: " + base);
System.out.println("Scale by 10^2: " + base.scaleByPowerOfTen(2));
System.out.println("Scale by 10^-2: " + base.scaleByPowerOfTen(-2));
// Different rounding modes
System.out.println("\nRounding modes:");
BigDecimal roundVal = new BigDecimal("2.5");
System.out.println("Value: " + roundVal);
System.out.println("CEILING: " + roundVal.setScale(0, RoundingMode.CEILING));
System.out.println("FLOOR: " + roundVal.setScale(0, RoundingMode.FLOOR));
System.out.println("UP: " + roundVal.setScale(0, RoundingMode.UP));
System.out.println("DOWN: " + roundVal.setScale(0, RoundingMode.DOWN));
System.out.println("HALF_UP: " + roundVal.setScale(0, RoundingMode.HALF_UP));
System.out.println("HALF_DOWN: " + roundVal.setScale(0, RoundingMode.HALF_DOWN));
System.out.println("HALF_EVEN: " + roundVal.setScale(0, RoundingMode.HALF_EVEN));
// Negative values
System.out.println("\nRounding negative values:");
BigDecimal negVal = new BigDecimal("-2.5");
System.out.println("Value: " + negVal);
System.out.println("HALF_UP: " + negVal.setScale(0, RoundingMode.HALF_UP));
System.out.println("HALF_EVEN: " + negVal.setScale(0, RoundingMode.HALF_EVEN));
// Financial rounding (2 decimals)
System.out.println("\nFinancial rounding:");
BigDecimal[] prices = {
new BigDecimal("19.994"),
new BigDecimal("19.995"),
new BigDecimal("19.996")
};
for (BigDecimal price : prices) {
BigDecimal rounded = price.setScale(2, RoundingMode.HALF_UP);
System.out.println("$" + price + " -> $" + rounded);
}
// Precision control
System.out.println("\nPrecision:");
BigDecimal precise = new BigDecimal("123.456789");
System.out.println("Original: " + precise);
System.out.println("Precision: " + precise.precision());
System.out.println("Scale: " + precise.scale());
// ulp (unit in last place)
System.out.println("\nulp:");
BigDecimal val3 = new BigDecimal("1.5");
System.out.println("Value: " + val3);
System.out.println("ulp: " + val3.ulp());
}
//help h1
// .scale() - get decimal places
// .precision() - get total significant digits
// .setScale(n, roundingMode) - set decimal places
// .stripTrailingZeros() - remove trailing zeros
// .movePointLeft(n), .movePointRight(n)
// .scaleByPowerOfTen(n) - multiply by 10^n
// RoundingMode: HALF_UP, HALF_EVEN, CEILING, FLOOR, etc.
// Use setScale(2, HALF_UP) for currency
//end
}
num1 ← 123.45, num2 ← 0.0012, valueText ← 12.3456, value ← 12.3456
6public class Scale {7 public static void main(String[] args) {8 // Scale: number of digits to the right of decimal point9 // Precision: total number of significant digits10 11 BigDecimal num1→ 123.45 = new BigDecimal("123.45");12 System.out.println("Number: " + num1123.45);13 System.out.println("Scale: " + num1.scale());14 System.out.println("Precision: " + num1.precision());15 System.out.println();1617 BigDecimal num2→ 0.0012 = new BigDecimal("0.0012");18 System.out.println("Number: " + num20.0012);19 System.out.println("Scale: " + num2.scale());20 System.out.println("Precision: " + num2.precision());21 System.out.println();2223 // setScale24 System.out.println("setScale:");25 String valueText→ 12.3456 = "12.3456"; //@valueText="9.995", "2.500"26 BigDecimal value→ 12.3456 = new BigDecimal(valueText);27 System.out.println("Original: " + value12.3456);28 29 BigDecimal rounded2→ 12.35 = value.setScale(2, RoundingMode.HALF_UP);30 System.out.println("2 decimals (HALF_UP): " + rounded212.35);31 32 BigDecimal rounded0→ 12 = value.setScale(0, RoundingMode.HALF_UP);33 System.out.println("0 decimals (HALF_UP): " + rounded012);34 35 BigDecimal rounded4→ 12.3456 = value.setScale(4, RoundingMode.HALF_UP);36 System.out.println("4 decimals (HALF_UP): " + rounded412.3456);3738 // Increase scale (add trailing zeros)39 System.out.println("\nIncrease scale:");40 BigDecimal val→ 10.5 = new BigDecimal("10.5");41 System.out.println("Original: " + val10.5 + " (scale: " + val.scale() + ")");42 BigDecimal increased→ 10.5000 = val.setScale(4, RoundingMode.UNNECESSARY);43 System.out.println("Scale 4: " + increased10.5000 + " (scale: " + increased.scale() + ")");4445 // Decrease scale (requires rounding)46 System.out.println("\nDecrease scale:");47 BigDecimal val2→ 10.5678 = new BigDecimal("10.5678");48 System.out.println("Original: " + val210.5678 + " (scale: " + val2.scale() + ")");49 BigDecimal decreased→ 10.57 = val2.setScale(2, RoundingMode.HALF_UP);50 System.out.println("Scale 2: " + decreased10.57 + " (scale: " + decreased.scale() + ")");5152 // stripTrailingZeros53 System.out.println("\nstripTrailingZeros:");54 BigDecimal withZeros→ 123.4500 = new BigDecimal("123.4500");55 System.out.println("Original: " + withZeros123.4500 + " (scale: " + withZeros.scale() + ")");56 BigDecimal stripped→ 123.45 = withZeros.stripTrailingZeros();57 System.out.println("Stripped: " + stripped123.45 + " (scale: " + stripped.scale() + ")");5859 // movePointLeft and movePointRight60 System.out.println("\nmovePointLeft and movePointRight:");61 BigDecimal num→ 123.45 = new BigDecimal("123.45");62 System.out.println("Original: " + num123.45);63 System.out.println("Move point left 2: " + num.movePointLeft(2));64 System.out.println("Move point right 2: " + num.movePointRight(2));6566 // scaleByPowerOfTen67 System.out.println("\nscaleByPowerOfTen:");68 BigDecimal base→ 1.5 = new BigDecimal("1.5");69 System.out.println("Original: " + base1.5);70 System.out.println("Scale by 10^2: " + base.scaleByPowerOfTen(2));71 System.out.println("Scale by 10^-2: " + base.scaleByPowerOfTen(-2));7273 // Different rounding modes74 System.out.println("\nRounding modes:");75 BigDecimal roundVal→ 2.5 = new BigDecimal("2.5");76 System.out.println("Value: " + roundVal2.5);77 78 System.out.println("CEILING: " + roundVal.setScale(0, RoundingMode.CEILING));79 System.out.println("FLOOR: " + roundVal.setScale(0, RoundingMode.FLOOR));80 System.out.println("UP: " + roundVal.setScale(0, RoundingMode.UP));81 System.out.println("DOWN: " + roundVal.setScale(0, RoundingMode.DOWN));82 System.out.println("HALF_UP: " + roundVal.setScale(0, RoundingMode.HALF_UP));83 System.out.println("HALF_DOWN: " + roundVal.setScale(0, RoundingMode.HALF_DOWN));84 System.out.println("HALF_EVEN: " + roundVal.setScale(0, RoundingMode.HALF_EVEN));8586 // Negative values87 System.out.println("\nRounding negative values:");88 BigDecimal negVal→ -2.5 = new BigDecimal("-2.5");89 System.out.println("Value: " + negVal-2.5);90 System.out.println("HALF_UP: " + negVal.setScale(0, RoundingMode.HALF_UP));91 System.out.println("HALF_EVEN: " + negVal.setScale(0, RoundingMode.HALF_EVEN));9293 // Financial rounding (2 decimals)94 System.out.println("\nFinancial rounding:");95 BigDecimal[] prices = {96 new BigDecimal("19.994"),97 new BigDecimal("19.995"),98 new BigDecimal("19.996")99 };outputNumber: 123.45 Scale: 2 Precision: 5 Number: 0.0012 Scale: 4 Precision: 2 setScale: Original: 12.3456 2 decimals (HALF_UP): 12.35 0 decimals (HALF_UP): 12 4 decimals (HALF_UP): 12.3456 Increase scale: Original: 10.5 (scale: 1) Scale 4: 10.5000 (scale: 4) Decrease scale: Original: 10.5678 (scale: 4) Scale 2: 10.57 (scale: 2) stripTrailingZeros: Original: 123.4500 (scale: 4) Stripped: 123.45 (scale: 2) movePointLeft and movePointRight: Original: 123.45 Move point left 2: 1.2345 Move point right 2: 12345 scaleByPowerOfTen: Original: 1.5 Scale by 10^2: 1.5E+2 Scale by 10^-2: 0.015 Rounding modes: Value: 2.5 CEILING: 3 FLOOR: 2 UP: 3 DOWN: 2 HALF_UP: 3 HALF_DOWN: 2 HALF_EVEN: 2 Rounding negative values: Value: -2.5 HALF_UP: -3 HALF_EVEN: -2 Financial rounding:rounded ← 19.99
pass 1 of 3101for (BigDecimal price19.994 : prices) {102 BigDecimal rounded→ 19.99 = price.setScale(2, RoundingMode.HALF_UP);103 System.out.println("$" + price19.994 + " -> $" + rounded19.99);104}output$19.994 -> $19.99All 3 passes — pass 1 is the card above pass pricerounded1 19.994 19.99 2 19.995 20.00 3 19.996 20.00 precise ← 123.456789, val3 ← 1.5
106 // Precision control107 System.out.println("\nPrecision:");108 BigDecimal precise→ 123.456789 = new BigDecimal("123.456789");109 System.out.println("Original: " + precise123.456789);110 System.out.println("Precision: " + precise.precision());111 System.out.println("Scale: " + precise.scale());112113 // ulp (unit in last place)114 System.out.println("\nulp:");115 BigDecimal val3→ 1.5 = new BigDecimal("1.5");116 System.out.println("Value: " + val31.5);117 System.out.println("ulp: " + val3.ulp());118}output Precision: Original: 123.456789 Precision: 9 Scale: 6 ulp: Value: 1.5 ulp: 0.1
num1 ← 123.45, num2 ← 0.0012, valueText ← 9.995, value ← 9.995
6public class Scale {7 public static void main(String[] args) {8 // Scale: number of digits to the right of decimal point9 // Precision: total number of significant digits10 11 BigDecimal num1→ 123.45 = new BigDecimal("123.45");12 System.out.println("Number: " + num1123.45);13 System.out.println("Scale: " + num1.scale());14 System.out.println("Precision: " + num1.precision());15 System.out.println();1617 BigDecimal num2→ 0.0012 = new BigDecimal("0.0012");18 System.out.println("Number: " + num20.0012);19 System.out.println("Scale: " + num2.scale());20 System.out.println("Precision: " + num2.precision());21 System.out.println();2223 // setScale24 System.out.println("setScale:");25 String valueText→ 9.995 = "9.995";26 BigDecimal value→ 9.995 = new BigDecimal(valueText);27 System.out.println("Original: " + value9.995);28 29 BigDecimal rounded2→ 10.00 = value.setScale(2, RoundingMode.HALF_UP);30 System.out.println("2 decimals (HALF_UP): " + rounded210.00);31 32 BigDecimal rounded0→ 10 = value.setScale(0, RoundingMode.HALF_UP);33 System.out.println("0 decimals (HALF_UP): " + rounded010);34 35 BigDecimal rounded4→ 9.9950 = value.setScale(4, RoundingMode.HALF_UP);36 System.out.println("4 decimals (HALF_UP): " + rounded49.9950);3738 // Increase scale (add trailing zeros)39 System.out.println("\nIncrease scale:");40 BigDecimal val→ 10.5 = new BigDecimal("10.5");41 System.out.println("Original: " + val10.5 + " (scale: " + val.scale() + ")");42 BigDecimal increased→ 10.5000 = val.setScale(4, RoundingMode.UNNECESSARY);43 System.out.println("Scale 4: " + increased10.5000 + " (scale: " + increased.scale() + ")");4445 // Decrease scale (requires rounding)46 System.out.println("\nDecrease scale:");47 BigDecimal val2→ 10.5678 = new BigDecimal("10.5678");48 System.out.println("Original: " + val210.5678 + " (scale: " + val2.scale() + ")");49 BigDecimal decreased→ 10.57 = val2.setScale(2, RoundingMode.HALF_UP);50 System.out.println("Scale 2: " + decreased10.57 + " (scale: " + decreased.scale() + ")");5152 // stripTrailingZeros53 System.out.println("\nstripTrailingZeros:");54 BigDecimal withZeros→ 123.4500 = new BigDecimal("123.4500");55 System.out.println("Original: " + withZeros123.4500 + " (scale: " + withZeros.scale() + ")");56 BigDecimal stripped→ 123.45 = withZeros.stripTrailingZeros();57 System.out.println("Stripped: " + stripped123.45 + " (scale: " + stripped.scale() + ")");5859 // movePointLeft and movePointRight60 System.out.println("\nmovePointLeft and movePointRight:");61 BigDecimal num→ 123.45 = new BigDecimal("123.45");62 System.out.println("Original: " + num123.45);63 System.out.println("Move point left 2: " + num.movePointLeft(2));64 System.out.println("Move point right 2: " + num.movePointRight(2));6566 // scaleByPowerOfTen67 System.out.println("\nscaleByPowerOfTen:");68 BigDecimal base→ 1.5 = new BigDecimal("1.5");69 System.out.println("Original: " + base1.5);70 System.out.println("Scale by 10^2: " + base.scaleByPowerOfTen(2));71 System.out.println("Scale by 10^-2: " + base.scaleByPowerOfTen(-2));7273 // Different rounding modes74 System.out.println("\nRounding modes:");75 BigDecimal roundVal→ 2.5 = new BigDecimal("2.5");76 System.out.println("Value: " + roundVal2.5);77 78 System.out.println("CEILING: " + roundVal.setScale(0, RoundingMode.CEILING));79 System.out.println("FLOOR: " + roundVal.setScale(0, RoundingMode.FLOOR));80 System.out.println("UP: " + roundVal.setScale(0, RoundingMode.UP));81 System.out.println("DOWN: " + roundVal.setScale(0, RoundingMode.DOWN));82 System.out.println("HALF_UP: " + roundVal.setScale(0, RoundingMode.HALF_UP));83 System.out.println("HALF_DOWN: " + roundVal.setScale(0, RoundingMode.HALF_DOWN));84 System.out.println("HALF_EVEN: " + roundVal.setScale(0, RoundingMode.HALF_EVEN));8586 // Negative values87 System.out.println("\nRounding negative values:");88 BigDecimal negVal→ -2.5 = new BigDecimal("-2.5");89 System.out.println("Value: " + negVal-2.5);90 System.out.println("HALF_UP: " + negVal.setScale(0, RoundingMode.HALF_UP));91 System.out.println("HALF_EVEN: " + negVal.setScale(0, RoundingMode.HALF_EVEN));9293 // Financial rounding (2 decimals)94 System.out.println("\nFinancial rounding:");95 BigDecimal[] prices = {96 new BigDecimal("19.994"),97 new BigDecimal("19.995"),98 new BigDecimal("19.996")99 };outputNumber: 123.45 Scale: 2 Precision: 5 Number: 0.0012 Scale: 4 Precision: 2 setScale: Original: 9.995 2 decimals (HALF_UP): 10.00 0 decimals (HALF_UP): 10 4 decimals (HALF_UP): 9.9950 Increase scale: Original: 10.5 (scale: 1) Scale 4: 10.5000 (scale: 4) Decrease scale: Original: 10.5678 (scale: 4) Scale 2: 10.57 (scale: 2) stripTrailingZeros: Original: 123.4500 (scale: 4) Stripped: 123.45 (scale: 2) movePointLeft and movePointRight: Original: 123.45 Move point left 2: 1.2345 Move point right 2: 12345 scaleByPowerOfTen: Original: 1.5 Scale by 10^2: 1.5E+2 Scale by 10^-2: 0.015 Rounding modes: Value: 2.5 CEILING: 3 FLOOR: 2 UP: 3 DOWN: 2 HALF_UP: 3 HALF_DOWN: 2 HALF_EVEN: 2 Rounding negative values: Value: -2.5 HALF_UP: -3 HALF_EVEN: -2 Financial rounding:rounded ← 19.99
pass 1 of 3101for (BigDecimal price19.994 : prices) {102 BigDecimal rounded→ 19.99 = price.setScale(2, RoundingMode.HALF_UP);103 System.out.println("$" + price19.994 + " -> $" + rounded19.99);104}output$19.994 -> $19.99All 3 passes — pass 1 is the card above pass pricerounded1 19.994 19.99 2 19.995 20.00 3 19.996 20.00 precise ← 123.456789, val3 ← 1.5
106 // Precision control107 System.out.println("\nPrecision:");108 BigDecimal precise→ 123.456789 = new BigDecimal("123.456789");109 System.out.println("Original: " + precise123.456789);110 System.out.println("Precision: " + precise.precision());111 System.out.println("Scale: " + precise.scale());112113 // ulp (unit in last place)114 System.out.println("\nulp:");115 BigDecimal val3→ 1.5 = new BigDecimal("1.5");116 System.out.println("Value: " + val31.5);117 System.out.println("ulp: " + val3.ulp());118}output Precision: Original: 123.456789 Precision: 9 Scale: 6 ulp: Value: 1.5 ulp: 0.1
num1 ← 123.45, num2 ← 0.0012, valueText ← 2.500, value ← 2.500
6public class Scale {7 public static void main(String[] args) {8 // Scale: number of digits to the right of decimal point9 // Precision: total number of significant digits10 11 BigDecimal num1→ 123.45 = new BigDecimal("123.45");12 System.out.println("Number: " + num1123.45);13 System.out.println("Scale: " + num1.scale());14 System.out.println("Precision: " + num1.precision());15 System.out.println();1617 BigDecimal num2→ 0.0012 = new BigDecimal("0.0012");18 System.out.println("Number: " + num20.0012);19 System.out.println("Scale: " + num2.scale());20 System.out.println("Precision: " + num2.precision());21 System.out.println();2223 // setScale24 System.out.println("setScale:");25 String valueText→ 2.500 = "2.500";26 BigDecimal value→ 2.500 = new BigDecimal(valueText);27 System.out.println("Original: " + value2.500);28 29 BigDecimal rounded2→ 2.50 = value.setScale(2, RoundingMode.HALF_UP);30 System.out.println("2 decimals (HALF_UP): " + rounded22.50);31 32 BigDecimal rounded0→ 3 = value.setScale(0, RoundingMode.HALF_UP);33 System.out.println("0 decimals (HALF_UP): " + rounded03);34 35 BigDecimal rounded4→ 2.5000 = value.setScale(4, RoundingMode.HALF_UP);36 System.out.println("4 decimals (HALF_UP): " + rounded42.5000);3738 // Increase scale (add trailing zeros)39 System.out.println("\nIncrease scale:");40 BigDecimal val→ 10.5 = new BigDecimal("10.5");41 System.out.println("Original: " + val10.5 + " (scale: " + val.scale() + ")");42 BigDecimal increased→ 10.5000 = val.setScale(4, RoundingMode.UNNECESSARY);43 System.out.println("Scale 4: " + increased10.5000 + " (scale: " + increased.scale() + ")");4445 // Decrease scale (requires rounding)46 System.out.println("\nDecrease scale:");47 BigDecimal val2→ 10.5678 = new BigDecimal("10.5678");48 System.out.println("Original: " + val210.5678 + " (scale: " + val2.scale() + ")");49 BigDecimal decreased→ 10.57 = val2.setScale(2, RoundingMode.HALF_UP);50 System.out.println("Scale 2: " + decreased10.57 + " (scale: " + decreased.scale() + ")");5152 // stripTrailingZeros53 System.out.println("\nstripTrailingZeros:");54 BigDecimal withZeros→ 123.4500 = new BigDecimal("123.4500");55 System.out.println("Original: " + withZeros123.4500 + " (scale: " + withZeros.scale() + ")");56 BigDecimal stripped→ 123.45 = withZeros.stripTrailingZeros();57 System.out.println("Stripped: " + stripped123.45 + " (scale: " + stripped.scale() + ")");5859 // movePointLeft and movePointRight60 System.out.println("\nmovePointLeft and movePointRight:");61 BigDecimal num→ 123.45 = new BigDecimal("123.45");62 System.out.println("Original: " + num123.45);63 System.out.println("Move point left 2: " + num.movePointLeft(2));64 System.out.println("Move point right 2: " + num.movePointRight(2));6566 // scaleByPowerOfTen67 System.out.println("\nscaleByPowerOfTen:");68 BigDecimal base→ 1.5 = new BigDecimal("1.5");69 System.out.println("Original: " + base1.5);70 System.out.println("Scale by 10^2: " + base.scaleByPowerOfTen(2));71 System.out.println("Scale by 10^-2: " + base.scaleByPowerOfTen(-2));7273 // Different rounding modes74 System.out.println("\nRounding modes:");75 BigDecimal roundVal→ 2.5 = new BigDecimal("2.5");76 System.out.println("Value: " + roundVal2.5);77 78 System.out.println("CEILING: " + roundVal.setScale(0, RoundingMode.CEILING));79 System.out.println("FLOOR: " + roundVal.setScale(0, RoundingMode.FLOOR));80 System.out.println("UP: " + roundVal.setScale(0, RoundingMode.UP));81 System.out.println("DOWN: " + roundVal.setScale(0, RoundingMode.DOWN));82 System.out.println("HALF_UP: " + roundVal.setScale(0, RoundingMode.HALF_UP));83 System.out.println("HALF_DOWN: " + roundVal.setScale(0, RoundingMode.HALF_DOWN));84 System.out.println("HALF_EVEN: " + roundVal.setScale(0, RoundingMode.HALF_EVEN));8586 // Negative values87 System.out.println("\nRounding negative values:");88 BigDecimal negVal→ -2.5 = new BigDecimal("-2.5");89 System.out.println("Value: " + negVal-2.5);90 System.out.println("HALF_UP: " + negVal.setScale(0, RoundingMode.HALF_UP));91 System.out.println("HALF_EVEN: " + negVal.setScale(0, RoundingMode.HALF_EVEN));9293 // Financial rounding (2 decimals)94 System.out.println("\nFinancial rounding:");95 BigDecimal[] prices = {96 new BigDecimal("19.994"),97 new BigDecimal("19.995"),98 new BigDecimal("19.996")99 };outputNumber: 123.45 Scale: 2 Precision: 5 Number: 0.0012 Scale: 4 Precision: 2 setScale: Original: 2.500 2 decimals (HALF_UP): 2.50 0 decimals (HALF_UP): 3 4 decimals (HALF_UP): 2.5000 Increase scale: Original: 10.5 (scale: 1) Scale 4: 10.5000 (scale: 4) Decrease scale: Original: 10.5678 (scale: 4) Scale 2: 10.57 (scale: 2) stripTrailingZeros: Original: 123.4500 (scale: 4) Stripped: 123.45 (scale: 2) movePointLeft and movePointRight: Original: 123.45 Move point left 2: 1.2345 Move point right 2: 12345 scaleByPowerOfTen: Original: 1.5 Scale by 10^2: 1.5E+2 Scale by 10^-2: 0.015 Rounding modes: Value: 2.5 CEILING: 3 FLOOR: 2 UP: 3 DOWN: 2 HALF_UP: 3 HALF_DOWN: 2 HALF_EVEN: 2 Rounding negative values: Value: -2.5 HALF_UP: -3 HALF_EVEN: -2 Financial rounding:rounded ← 19.99
pass 1 of 3101for (BigDecimal price19.994 : prices) {102 BigDecimal rounded→ 19.99 = price.setScale(2, RoundingMode.HALF_UP);103 System.out.println("$" + price19.994 + " -> $" + rounded19.99);104}output$19.994 -> $19.99All 3 passes — pass 1 is the card above pass pricerounded1 19.994 19.99 2 19.995 20.00 3 19.996 20.00 precise ← 123.456789, val3 ← 1.5
106 // Precision control107 System.out.println("\nPrecision:");108 BigDecimal precise→ 123.456789 = new BigDecimal("123.456789");109 System.out.println("Original: " + precise123.456789);110 System.out.println("Precision: " + precise.precision());111 System.out.println("Scale: " + precise.scale());112113 // ulp (unit in last place)114 System.out.println("\nulp:");115 BigDecimal val3→ 1.5 = new BigDecimal("1.5");116 System.out.println("Value: " + val31.5);117 System.out.println("ulp: " + val3.ulp());118}output Precision: Original: 123.456789 Precision: 9 Scale: 6 ulp: Value: 1.5 ulp: 0.1
Scale
The number of digits to the right of the decimal point. Use setScale() with a RoundingMode to control precision.
Comparison Operations
Compare BigDecimal values properly.
Comparison.java
Replay: real traced execution (multi-file project)
// Comparison operations
import java.math.BigDecimal;
public class Comparison {
public static void main(String[] args) {
BigDecimal a = new BigDecimal("10.5");
BigDecimal b = new BigDecimal("20.3");
BigDecimal c = new BigDecimal("10.5");
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
System.out.println();
// compareTo
System.out.println("compareTo:");
System.out.println("a.compareTo(b): " + a.compareTo(b)); // -1
System.out.println("b.compareTo(a): " + b.compareTo(a)); // 1
System.out.println("a.compareTo(c): " + a.compareTo(c)); // 0
// Comparison helpers
System.out.println("\nComparison helpers:");
System.out.println("a < b: " + (a.compareTo(b) < 0));
System.out.println("a <= b: " + (a.compareTo(b) <= 0));
System.out.println("a > b: " + (a.compareTo(b) > 0));
System.out.println("a >= b: " + (a.compareTo(b) >= 0));
System.out.println("a == c: " + (a.compareTo(c) == 0));
// equals vs compareTo
System.out.println("\nequals vs compareTo:");
BigDecimal d1 = new BigDecimal("1.0");
BigDecimal d2 = new BigDecimal("1.00");
System.out.println("d1 = " + d1 + " (scale: " + d1.scale() + ")");
System.out.println("d2 = " + d2 + " (scale: " + d2.scale() + ")");
System.out.println("d1.equals(d2): " + d1.equals(d2)); // false (different scale)
System.out.println("d1.compareTo(d2): " + d1.compareTo(d2)); // 0 (same value)
// max and min
System.out.println("\nmax and min:");
System.out.println("max(a, b): " + a.max(b));
System.out.println("min(a, b): " + a.min(b));
// signum
System.out.println("\nsignum:");
BigDecimal pos = new BigDecimal("10.5");
BigDecimal neg = new BigDecimal("-10.5");
BigDecimal zero = BigDecimal.ZERO;
System.out.println("signum(10.5): " + pos.signum()); // 1
System.out.println("signum(-10.5): " + neg.signum()); // -1
System.out.println("signum(0): " + zero.signum()); // 0
// Find max in array
System.out.println("\nFind max in array:");
BigDecimal[] numbers = {
new BigDecimal("12.5"),
new BigDecimal("98.7"),
new BigDecimal("45.2"),
new BigDecimal("23.8")
};
BigDecimal max = findMax(numbers);
BigDecimal min = findMin(numbers);
System.out.println("Max: " + max);
System.out.println("Min: " + min);
// Sort array
System.out.println("\nSort array:");
java.util.Arrays.sort(numbers);
System.out.println("Sorted: " + java.util.Arrays.toString(numbers));
// Range check
System.out.println("\nRange check:");
BigDecimal value = new BigDecimal("15.5");
BigDecimal lower = new BigDecimal("10.0");
BigDecimal upper = new BigDecimal("20.0");
boolean inRange = value.compareTo(lower) >= 0 && value.compareTo(upper) <= 0;
System.out.println(value + " in [" + lower + ", " + upper + "]: " + inRange);
// Zero check
System.out.println("\nZero check:");
BigDecimal val1 = new BigDecimal("0");
BigDecimal val2 = new BigDecimal("0.00");
System.out.println(val1 + " is zero: " + (val1.compareTo(BigDecimal.ZERO) == 0));
System.out.println(val2 + " is zero: " + (val2.compareTo(BigDecimal.ZERO) == 0));
System.out.println("val1.equals(ZERO): " + val1.equals(BigDecimal.ZERO));
System.out.println("val2.equals(ZERO): " + val2.equals(BigDecimal.ZERO)); // false (different scale)
// Sign check
System.out.println("\nSign check:");
System.out.println("pos > 0: " + (pos.signum() > 0));
System.out.println("neg < 0: " + (neg.signum() < 0));
System.out.println("zero == 0: " + (zero.signum() == 0));
// Tolerance comparison
System.out.println("\nTolerance comparison:");
BigDecimal v1 = new BigDecimal("10.001");
BigDecimal v2 = new BigDecimal("10.002");
BigDecimal tolerance = new BigDecimal("0.01");
boolean approxEqual = v1.subtract(v2).abs().compareTo(tolerance) <= 0;
System.out.println(v1 + " ≈ " + v2 + " (tolerance " + tolerance + "): " + approxEqual);
}
public static BigDecimal findMax(BigDecimal[] arr) {
BigDecimal max = arr[0];
for (BigDecimal val : arr) {
max = max.max(val);
}
return max;
}
public static BigDecimal findMin(BigDecimal[] arr) {
BigDecimal min = arr[0];
for (BigDecimal val : arr) {
min = min.min(val);
}
return min;
}
//help h1
// .compareTo(other) - returns -1, 0, or 1
// .equals(other) - considers scale (use compareTo for value equality)
// .max(other), .min(other)
// .signum() - sign (-1, 0, or 1)
// Use compareTo for value comparison
// Use equals only when scale matters
// For approximate equality, use tolerance
//end
}
a ← 10.5, b ← 20.3, c ← 10.5, d1 ← 1.0, d2 ← 1.00, pos ← 10.5
5public class Comparison {6 public static void main(String[] args) {7 BigDecimal a→ 10.5 = new BigDecimal("10.5");8 BigDecimal b→ 20.3 = new BigDecimal("20.3");9 BigDecimal c→ 10.5 = new BigDecimal("10.5");10 11 System.out.println("a = " + a10.5);12 System.out.println("b = " + b20.3);13 System.out.println("c = " + c10.5);14 System.out.println();1516 // compareTo17 System.out.println("compareTo:");18 System.out.println("a.compareTo(b): " + a.compareTo(b20.3)); // -119 System.out.println("b.compareTo(a): " + b.compareTo(a10.5)); // 120 System.out.println("a.compareTo(c): " + a.compareTo(c10.5)); // 02122 // Comparison helpers23 System.out.println("\nComparison helpers:");24 System.out.println("a < b: " + (a.compareTo(b20.3) < 0));25 System.out.println("a <= b: " + (a.compareTo(b20.3) <= 0));26 System.out.println("a > b: " + (a.compareTo(b20.3) > 0));27 System.out.println("a >= b: " + (a.compareTo(b20.3) >= 0));28 System.out.println("a == c: " + (a.compareTo(c10.5) == 0));2930 // equals vs compareTo31 System.out.println("\nequals vs compareTo:");32 BigDecimal d1→ 1.0 = new BigDecimal("1.0");33 BigDecimal d2→ 1.00 = new BigDecimal("1.00");34 35 System.out.println("d1 = " + d11.0 + " (scale: " + d1.scale() + ")");36 System.out.println("d2 = " + d21.00 + " (scale: " + d2.scale() + ")");37 System.out.println("d1.equals(d2): " + d1.equals(d21.00)); // false (different scale)38 System.out.println("d1.compareTo(d2): " + d1.compareTo(d21.00)); // 0 (same value)3940 // max and min41 System.out.println("\nmax and min:");42 System.out.println("max(a, b): " + a.max(b20.3));43 System.out.println("min(a, b): " + a.min(b20.3));4445 // signum46 System.out.println("\nsignum:");47 BigDecimal pos→ 10.5 = new BigDecimal("10.5");48 BigDecimal neg→ -10.5 = new BigDecimal("-10.5");49 BigDecimal zero→ 0 = BigDecimal.ZERO;50 51 System.out.println("signum(10.5): " + pos.signum()); // 152 System.out.println("signum(-10.5): " + neg.signum()); // -153 System.out.println("signum(0): " + zero.signum()); // 05455 // Find max in array56 System.out.println("\nFind max in array:");57 BigDecimal[] numbers = {58 new BigDecimal("12.5"),59 new BigDecimal("98.7"),60 new BigDecimal("45.2"),61 new BigDecimal("23.8")62 };63 64 BigDecimal max = findMax(numbers);65 BigDecimal min = findMin(numbers);outputa = 10.5 b = 20.3 c = 10.5 compareTo: a.compareTo(b): -1 b.compareTo(a): 1 a.compareTo(c): 0 Comparison helpers: a < b: true a <= b: true a > b: false a >= b: false a == c: true equals vs compareTo: d1 = 1.0 (scale: 1) d2 = 1.00 (scale: 2) d1.equals(d2): false d1.compareTo(d2): 0 max and min: max(a, b): 20.3 min(a, b): 10.5 signum: signum(10.5): 1 signum(-10.5): -1 signum(0): 0 Find max in array:max ← 12.5
107}108public static BigDecimal findMax(BigDecimal[] arr) {109 BigDecimal max→ 12.5 = arr[0]12.5;110 for (BigDecimal val : arr) {max ← 12.5
pass 1 of 4109BigDecimal max = arr[0];110for (BigDecimal val12.5 : arr) {111 max→ 12.5 = max.max(val12.5);112}All 4 passes — pass 1 is the card above pass valmax1 12.5 12.5 2 98.7 98.7 3 45.2 98.7 4 23.8 98.7 return max;
112 }113 return max98.7;114}max ← 98.7
64BigDecimal max→ 98.7 = findMax(numbers);65BigDecimal min = findMin(numbers);66System.out.println("Max: " + max);min ← 12.5
114}115public static BigDecimal findMin(BigDecimal[] arr) {116 BigDecimal min→ 12.5 = arr[0]12.5;117 for (BigDecimal val : arr) {min ← 12.5
pass 1 of 4116BigDecimal min = arr[0];117for (BigDecimal val12.5 : arr) {118 min→ 12.5 = min.min(val12.5);119}All 4 passes — pass 1 is the card above pass valmin1 12.5 12.5 2 98.7 12.5 3 45.2 12.5 4 23.8 12.5 return min;
119 }120 return min12.5;121}min ← 12.5, value ← 15.5, lower ← 10.0, upper ← 20.0, inRange ← true
64 BigDecimal max = findMax(numbers);65 BigDecimal min→ 12.5 = findMin(numbers);66 System.out.println("Max: " + max98.7);67 System.out.println("Min: " + min12.5);6869 // Sort array70 System.out.println("\nSort array:");71 java.util.Arrays.sort(numbers);72 System.out.println("Sorted: " + java.util.Arrays.toString(numbers));7374 // Range check75 System.out.println("\nRange check:");76 BigDecimal value→ 15.5 = new BigDecimal("15.5");77 BigDecimal lower→ 10.0 = new BigDecimal("10.0");78 BigDecimal upper→ 20.0 = new BigDecimal("20.0");79 80 boolean inRange→ true = value.compareTo(lower10.0) >= 0 && value.compareTo(upper20.0) <= 0;81 System.out.println(value15.5 + " in [" + lower10.0 + ", " + upper20.0 + "]: " + inRangetrue);8283 // Zero check84 System.out.println("\nZero check:");85 BigDecimal val1→ 0 = new BigDecimal("0");86 BigDecimal val2→ 0.00 = new BigDecimal("0.00");87 88 System.out.println(val10 + " is zero: " + (val1.compareTo(BigDecimal.ZERO) == 0));89 System.out.println(val20.00 + " is zero: " + (val2.compareTo(BigDecimal.ZERO) == 0));90 System.out.println("val1.equals(ZERO): " + val1.equals(BigDecimal.ZERO));91 System.out.println("val2.equals(ZERO): " + val2.equals(BigDecimal.ZERO)); // false (different scale)9293 // Sign check94 System.out.println("\nSign check:");95 System.out.println("pos > 0: " + (pos.signum() > 0));96 System.out.println("neg < 0: " + (neg.signum() < 0));97 System.out.println("zero == 0: " + (zero.signum() == 0));9899 // Tolerance comparison100 System.out.println("\nTolerance comparison:");101 BigDecimal v1→ 10.001 = new BigDecimal("10.001");102 BigDecimal v2→ 10.002 = new BigDecimal("10.002");103 BigDecimal tolerance→ 0.01 = new BigDecimal("0.01");104 105 boolean approxEqual→ true = v1.subtract(v210.002).abs().compareTo(tolerance0.01) <= 0;106 System.out.println(v110.001 + " ≈ " + v210.002 + " (tolerance " + tolerance0.01 + "): " + approxEqualtrue);107}outputMax: 98.7 Min: 12.5 Sort array: Sorted: [12.5, 23.8, 45.2, 98.7] Range check: 15.5 in [10.0, 20.0]: true Zero check: 0 is zero: true 0.00 is zero: true val1.equals(ZERO): true val2.equals(ZERO): false Sign check: pos > 0: true neg < 0: true zero == 0: true Tolerance comparison: 10.001 ≈ 10.002 (tolerance 0.01): true
compareTo vs equals
Use compareTo() for numeric equality (2.0 equals 2.00) and equals() only when scale must also match.
MathContext
Control precision and rounding behavior for operations.
Mathcontext.java
Replay: real traced execution (multi-file project)
// MathContext usage
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
public class Mathcontext {
public static void main(String[] args) {
// MathContext: precision and rounding mode
System.out.println("MathContext:");
// Predefined contexts
System.out.println("UNLIMITED: prec=" + MathContext.UNLIMITED.getPrecision() +
", rounding=" + MathContext.UNLIMITED.getRoundingMode());
System.out.println("DECIMAL32: prec=" + MathContext.DECIMAL32.getPrecision() +
", rounding=" + MathContext.DECIMAL32.getRoundingMode());
System.out.println("DECIMAL64: prec=" + MathContext.DECIMAL64.getPrecision() +
", rounding=" + MathContext.DECIMAL64.getRoundingMode());
System.out.println("DECIMAL128: prec=" + MathContext.DECIMAL128.getPrecision() +
", rounding=" + MathContext.DECIMAL128.getRoundingMode());
// Custom MathContext
System.out.println("\nCustom MathContext:");
MathContext mc10 = new MathContext(10, RoundingMode.HALF_UP);
System.out.println("Custom: prec=" + mc10.getPrecision() +
", rounding=" + mc10.getRoundingMode());
// Using MathContext in division
System.out.println("\nDivision with different precision:");
BigDecimal a = new BigDecimal("1");
BigDecimal b = new BigDecimal("3");
System.out.println("1/3 with DECIMAL32: " + a.divide(b, MathContext.DECIMAL32));
System.out.println("1/3 with DECIMAL64: " + a.divide(b, MathContext.DECIMAL64));
System.out.println("1/3 with DECIMAL128: " + a.divide(b, MathContext.DECIMAL128));
System.out.println("1/3 with MC(10): " + a.divide(b, mc10));
// Using MathContext in operations
System.out.println("\nOperations with MathContext:");
MathContext mc5 = new MathContext(5);
BigDecimal x = new BigDecimal("1.234567890");
BigDecimal y = new BigDecimal("2.345678901");
System.out.println("x = " + x);
System.out.println("y = " + y);
System.out.println();
System.out.println("add (MC5): " + x.add(y, mc5));
System.out.println("subtract (MC5): " + x.subtract(y, mc5));
System.out.println("multiply (MC5): " + x.multiply(y, mc5));
System.out.println("divide (MC5): " + x.divide(y, mc5));
// plus, minus (apply MathContext)
System.out.println("\nplus and minus:");
BigDecimal val = new BigDecimal("12.3456789");
System.out.println("Original: " + val);
System.out.println("plus(MC5): " + val.plus(mc5));
System.out.println("minus(MC5): " + val.negate().plus(mc5));
// Round method
System.out.println("\nround method:");
BigDecimal toRound = new BigDecimal("123.456789");
System.out.println("Original: " + toRound);
System.out.println("round(MC5): " + toRound.round(mc5));
MathContext mc3 = new MathContext(3);
System.out.println("round(MC3): " + toRound.round(mc3));
// Different rounding modes in MathContext
System.out.println("\nDifferent rounding modes:");
BigDecimal value = new BigDecimal("2.5");
MathContext mcUp = new MathContext(1, RoundingMode.UP);
MathContext mcDown = new MathContext(1, RoundingMode.DOWN);
MathContext mcHalfUp = new MathContext(1, RoundingMode.HALF_UP);
MathContext mcHalfEven = new MathContext(1, RoundingMode.HALF_EVEN);
System.out.println("Value: " + value);
System.out.println("UP: " + value.round(mcUp));
System.out.println("DOWN: " + value.round(mcDown));
System.out.println("HALF_UP: " + value.round(mcHalfUp));
System.out.println("HALF_EVEN: " + value.round(mcHalfEven));
// Practical: financial calculation
System.out.println("\nFinancial calculation:");
MathContext financial = new MathContext(10, RoundingMode.HALF_UP);
BigDecimal price = new BigDecimal("19.99");
BigDecimal taxRate = new BigDecimal("0.08");
BigDecimal quantity = new BigDecimal("3");
BigDecimal subtotal = price.multiply(quantity);
BigDecimal tax = subtotal.multiply(taxRate, financial)
.setScale(2, RoundingMode.HALF_UP);
BigDecimal total = subtotal.add(tax);
System.out.println("Price: $" + price);
System.out.println("Tax rate: " + taxRate.multiply(new BigDecimal("100")) + "%");
System.out.println("Quantity: " + quantity);
System.out.println("Subtotal: $" + subtotal);
System.out.println("Tax: $" + tax);
System.out.println("Total: $" + total.setScale(2, RoundingMode.HALF_UP));
// Scientific calculation with high precision
System.out.println("\nScientific calculation:");
MathContext mc50 = new MathContext(50, RoundingMode.HALF_UP);
// Calculate pi using Machin's formula (simplified)
// π/4 = 4 * arctan(1/5) - arctan(1/239)
// Using series: arctan(x) = x - x³/3 + x⁵/5 - x⁷/7 + ...
BigDecimal pi = calculatePi(20, mc50);
System.out.println("π (20 terms, 50 precision): " + pi);
// Compound interest with high precision
System.out.println("\nCompound interest (high precision):");
MathContext mc20 = new MathContext(20, RoundingMode.HALF_UP);
BigDecimal principal = new BigDecimal("10000");
BigDecimal rate = new BigDecimal("0.05");
int years = 30;
BigDecimal amount = principal;
for (int i = 0; i < years; i++) {
amount = amount.multiply(BigDecimal.ONE.add(rate), mc20);
}
System.out.println("Principal: $" + principal);
System.out.println("Rate: " + rate.multiply(new BigDecimal("100")) + "%");
System.out.println("Years: " + years);
System.out.println("Amount: $" + amount.setScale(2, RoundingMode.HALF_UP));
}
public static BigDecimal calculatePi(int terms, MathContext mc) {
BigDecimal sum = BigDecimal.ZERO;
for (int i = 0; i < terms; i++) {
BigDecimal term = BigDecimal.ONE.divide(
new BigDecimal(2 * i + 1), mc
);
if (i % 2 == 0) {
sum = sum.add(term, mc);
} else {
sum = sum.subtract(term, mc);
}
}
return sum.multiply(new BigDecimal("4"), mc);
}
//help h1
// MathContext(precision, roundingMode)
// MathContext.DECIMAL32/64/128 - predefined
// .divide(other, mc) - use MathContext
// .add/subtract/multiply(other, mc)
// .round(mc) - apply precision
// .plus(mc) - apply to current value
// Use for consistent precision in calculations
// Financial: MC(10-15, HALF_UP)
// Scientific: MC(50-100, HALF_UP)
//end
}
mc10 ← precision=10 roundingMode=HALF_UP, a ← 1, b ← 3, mc5 ← precision=5 roundingMode=HALF_UP
7public class Mathcontext {8 public static void main(String[] args) {9 // MathContext: precision and rounding mode10 System.out.println("MathContext:");11 12 // Predefined contexts13 System.out.println("UNLIMITED: prec=" + MathContext.UNLIMITED.getPrecision() + 14 ", rounding=" + MathContext.UNLIMITED.getRoundingMode());15 System.out.println("DECIMAL32: prec=" + MathContext.DECIMAL32.getPrecision() + 16 ", rounding=" + MathContext.DECIMAL32.getRoundingMode());17 System.out.println("DECIMAL64: prec=" + MathContext.DECIMAL64.getPrecision() + 18 ", rounding=" + MathContext.DECIMAL64.getRoundingMode());19 System.out.println("DECIMAL128: prec=" + MathContext.DECIMAL128.getPrecision() + 20 ", rounding=" + MathContext.DECIMAL128.getRoundingMode());2122 // Custom MathContext23 System.out.println("\nCustom MathContext:");24 MathContext mc10→ precision=10 roundingMode=HALF_UP = new MathContext(10, RoundingMode.HALF_UP);25 System.out.println("Custom: prec=" + mc10.getPrecision() + 26 ", rounding=" + mc10.getRoundingMode());2728 // Using MathContext in division29 System.out.println("\nDivision with different precision:");30 BigDecimal a→ 1 = new BigDecimal("1");31 BigDecimal b→ 3 = new BigDecimal("3");32 33 System.out.println("1/3 with DECIMAL32: " + a.divide(b3, MathContext.DECIMAL32));34 System.out.println("1/3 with DECIMAL64: " + a.divide(b3, MathContext.DECIMAL64));35 System.out.println("1/3 with DECIMAL128: " + a.divide(b3, MathContext.DECIMAL128));36 System.out.println("1/3 with MC(10): " + a.divide(b3, mc10precision=10 roundingMode=HALF_UP));3738 // Using MathContext in operations39 System.out.println("\nOperations with MathContext:");40 MathContext mc5→ precision=5 roundingMode=HALF_UP = new MathContext(5);41 42 BigDecimal x→ 1.234567890 = new BigDecimal("1.234567890");43 BigDecimal y→ 2.345678901 = new BigDecimal("2.345678901");44 45 System.out.println("x = " + x1.234567890);46 System.out.println("y = " + y2.345678901);47 System.out.println();48 49 System.out.println("add (MC5): " + x.add(y2.345678901, mc5precision=5 roundingMode=HALF_UP));50 System.out.println("subtract (MC5): " + x.subtract(y2.345678901, mc5precision=5 roundingMode=HALF_UP));51 System.out.println("multiply (MC5): " + x.multiply(y2.345678901, mc5precision=5 roundingMode=HALF_UP));52 System.out.println("divide (MC5): " + x.divide(y2.345678901, mc5precision=5 roundingMode=HALF_UP));5354 // plus, minus (apply MathContext)55 System.out.println("\nplus and minus:");56 BigDecimal val→ 12.3456789 = new BigDecimal("12.3456789");57 System.out.println("Original: " + val12.3456789);58 System.out.println("plus(MC5): " + val.plus(mc5precision=5 roundingMode=HALF_UP));59 System.out.println("minus(MC5): " + val.negate().plus(mc5precision=5 roundingMode=HALF_UP));6061 // Round method62 System.out.println("\nround method:");63 BigDecimal toRound→ 123.456789 = new BigDecimal("123.456789");64 System.out.println("Original: " + toRound123.456789);65 System.out.println("round(MC5): " + toRound.round(mc5precision=5 roundingMode=HALF_UP));66 67 MathContext mc3→ precision=3 roundingMode=HALF_UP = new MathContext(3);68 System.out.println("round(MC3): " + toRound.round(mc3precision=3 roundingMode=HALF_UP));6970 // Different rounding modes in MathContext71 System.out.println("\nDifferent rounding modes:");72 BigDecimal value→ 2.5 = new BigDecimal("2.5");73 74 MathContext mcUp→ precision=1 roundingMode=UP = new MathContext(1, RoundingMode.UP);75 MathContext mcDown→ precision=1 roundingMode=DOWN = new MathContext(1, RoundingMode.DOWN);76 MathContext mcHalfUp→ precision=1 roundingMode=HALF_UP = new MathContext(1, RoundingMode.HALF_UP);77 MathContext mcHalfEven→ precision=1 roundingMode=HALF_EVEN = new MathContext(1, RoundingMode.HALF_EVEN);78 79 System.out.println("Value: " + value2.5);80 System.out.println("UP: " + value.round(mcUpprecision=1 roundingMode=UP));81 System.out.println("DOWN: " + value.round(mcDownprecision=1 roundingMode=DOWN));82 System.out.println("HALF_UP: " + value.round(mcHalfUpprecision=1 roundingMode=HALF_UP));83 System.out.println("HALF_EVEN: " + value.round(mcHalfEvenprecision=1 roundingMode=HALF_EVEN));8485 // Practical: financial calculation86 System.out.println("\nFinancial calculation:");87 MathContext financial→ precision=10 roundingMode=HALF_UP = new MathContext(10, RoundingMode.HALF_UP);88 89 BigDecimal price→ 19.99 = new BigDecimal("19.99");90 BigDecimal taxRate→ 0.08 = new BigDecimal("0.08");91 BigDecimal quantity→ 3 = new BigDecimal("3");92 93 BigDecimal subtotal→ 59.97 = price.multiply(quantity3);94 BigDecimal tax→ 4.80 = subtotal.multiply(taxRate0.08, financialprecision=10 roundingMode=HALF_UP)95 .setScale(2, RoundingMode.HALF_UP);96 BigDecimal total→ 64.77 = subtotal.add(tax4.80);97 98 System.out.println("Price: $" + price19.99);99 System.out.println("Tax rate: " + taxRate.multiply(new BigDecimal("100")) + "%");100 System.out.println("Quantity: " + quantity3);101 System.out.println("Subtotal: $" + subtotal59.97);102 System.out.println("Tax: $" + tax4.80);103 System.out.println("Total: $" + total.setScale(2, RoundingMode.HALF_UP));104105 // Scientific calculation with high precision106 System.out.println("\nScientific calculation:");107 MathContext mc50→ precision=50 roundingMode=HALF_UP = new MathContext(50, RoundingMode.HALF_UP);108 109 // Calculate pi using Machin's formula (simplified)110 // π/4 = 4 * arctan(1/5) - arctan(1/239)111 // Using series: arctan(x) = x - x³/3 + x⁵/5 - x⁷/7 + ...112 113 BigDecimal pi = calculatePi(20, mc50precision=50 roundingMode=HALF_UP);114 System.out.println("π (20 terms, 50 precision): " + pi);outputMathContext: UNLIMITED: prec=0, rounding=HALF_UP DECIMAL32: prec=7, rounding=HALF_EVEN DECIMAL64: prec=16, rounding=HALF_EVEN DECIMAL128: prec=34, rounding=HALF_EVEN Custom MathContext: Custom: prec=10, rounding=HALF_UP Division with different precision: 1/3 with DECIMAL32: 0.3333333 1/3 with DECIMAL64: 0.3333333333333333 1/3 with DECIMAL128: 0.3333333333333333333333333333333333 1/3 with MC(10): 0.3333333333 Operations with MathContext: x = 1.234567890 y = 2.345678901 add (MC5): 3.5802 subtract (MC5): -1.1111 multiply (MC5): 2.8959 divide (MC5): 0.52632 plus and minus: Original: 12.3456789 plus(MC5): 12.346 minus(MC5): -12.346 round method: Original: 123.456789 round(MC5): 123.46 round(MC3): 123 Different rounding modes: Value: 2.5 UP: 3 DOWN: 2 HALF_UP: 3 HALF_EVEN: 2 Financial calculation: Price: $19.99 Tax rate: 8.00% Quantity: 3 Subtotal: $59.97 Tax: $4.80 Total: $64.77 Scientific calculation:sum ← 0
133}134public static BigDecimal calculatePi(int terms20, MathContext mcprecision=50 roundingMode=HALF_UP) {135 BigDecimal sum→ 0 = BigDecimal.ZERO;136 for (int i = 0; i < terms; i++) {term ← 1
pass 1 of 20135BigDecimal sum = BigDecimal.ZERO;136for (int i0 = 0; i < terms20; i++) {137 BigDecimal term→ 1 = BigDecimal.ONE.divide(138 new BigDecimal(2 * i + 1), mcprecision=50 roundingMode=HALF_UP139 );140 if (i % 2 == 0) {20 passes — pass 1 is the card above pass iterm1 0 1 2 1 0.33333333333333333333333333333333333333333333333333 3 2 0.2 4 3 0.14285714285714285714285714285714285714285714285714 5 4 0.11111111111111111111111111111111111111111111111111 6 5 0.090909090909090909090909090909090909090909090909091 7 6 0.076923076923076923076923076923076923076923076923077 8 7 0.066666666666666666666666666666666666666666666666667 9 8 0.058823529411764705882352941176470588235294117647059 ⋯ 9 more passes ⋯ 19 18 0.027027027027027027027027027027027027027027027027027 20 19 0.025641025641025641025641025641025641025641025641026 sum ← 1
pass 1 of 10139);140if (i0 % 2 == 0) {141 sum→ 1 = sum.add(term1, mcprecision=50 roundingMode=HALF_UP);142} else {All 10 passes — pass 1 is the card above pass itermsum1 0 1 1 2 2 0.2 0.86666666666666666666666666666666666666666666666667 3 4 0.11111111111111111111111111111111111111111111111111 0.83492063492063492063492063492063492063492063492064 4 6 0.076923076923076923076923076923076923076923076923077 0.82093462093462093462093462093462093462093462093463 5 8 0.058823529411764705882352941176470588235294117647059 0.81309148367971897383662089544442485618956207191502 6 10 0.047619047619047619047619047619047619047619047619048 0.80807895235139817183160836411610405418454954058670 7 12 0.04 0.80460069148183295444030401629001709766281041015192 8 14 0.034482758620689655172413793103448275862068965517241 0.80204641306548557257568077235642833648784233863212 9 16 0.030303030303030303030303030303030303030303030303030 0.80009137885238684334791928653042638145362923990289 10 18 0.027027027027027027027027027027027027027027027027027 0.79854697730798529894637488498602483705208483835849 sum ← 0.66666666666666666666666666666666666666666666666667
pass 1 of 10141 sum = sum.add(term, mc);142} else {143 sum→ 0.66666666666666666666666666666666666666666666666667 = sum.subtract(term0.33333333333333333333333333333333333333333333333333, mcprecision=50 roundingMode=HALF_UP);144}All 10 passes — pass 1 is the card above pass termsum1 0.33333333333333333333333333333333333333333333333333 0.66666666666666666666666666666666666666666666666667 2 0.14285714285714285714285714285714285714285714285714 0.72380952380952380952380952380952380952380952380953 3 0.090909090909090909090909090909090909090909090909091 0.74401154401154401154401154401154401154401154401155 4 0.066666666666666666666666666666666666666666666666667 0.75426795426795426795426795426795426795426795426796 5 0.052631578947368421052631578947368421052631578947368 0.76045990473235055278398931649705643513693049296765 6 0.043478260869565217391304347826086956521739130434783 0.76460069148183295444030401629001709766281041015192 7 0.037037037037037037037037037037037037037037037037037 0.76756365444479591740326697925298006062577337311488 8 0.032258064516129032258064516129032258064516129032258 0.76978834854935654031761625622739607842332620959986 9 0.028571428571428571428571428571428571428571428571429 0.77151995028095827191934785795899781002505781133146 10 0.025641025641025641025641025641025641025641025641026 0.77290595166695965792073385934499919602644381271746 return sum.multiply(new BigDecimal("4"), mc);
145 }146 return sum.multiply(new BigDecimal("4"), mcprecision=50 roundingMode=HALF_UP);147}pi ← 3.0916238066678386316829354373799967841057752508698, mc20 ← precision=20 roundingMode=HALF_UP
113BigDecimal pi→ 3.0916238066678386316829354373799967841057752508698 = calculatePi(20, mc50precision=50 roundingMode=HALF_UP);114System.out.println("π (20 terms, 50 precision): " + pi3.0916238066678386316829354373799967841057752508698);115116// Compound interest with high precision117System.out.println("\nCompound interest (high precision):");118MathContext mc20→ precision=20 roundingMode=HALF_UP = new MathContext(20, RoundingMode.HALF_UP);119120BigDecimal principal→ 10000 = new BigDecimal("10000");121BigDecimal rate→ 0.05 = new BigDecimal("0.05");122int years→ 30 = 30;123124BigDecimal amount→ 10000 = principal;125for (int i = 0; i < years; i++) {outputπ (20 terms, 50 precision): 3.0916238066678386316829354373799967841057752508698 Compound interest (high precision):amount ← 10500.00
pass 1 of 30124BigDecimal amount = principal;125for (int i0 = 0; i < years30; i++) {126 amount→ 10500.00 = amount.multiply(BigDecimal.ONE.add(rate0.05), mc20precision=20 roundingMode=HALF_UP);127}30 passes — pass 1 is the card above pass iamount1 0 10500.00 2 1 11025.0000 3 2 11576.250000 4 3 12155.06250000 5 4 12762.8156250000 6 5 13400.956406250000 7 6 14071.00422656250000 8 7 14774.554437890625000 9 8 15513.282159785156250 ⋯ 19 more passes ⋯ 29 28 41161.355953815828658 30 29 43219.423751506620091 System.out.println("Principal: $" + principal);
129 System.out.println("Principal: $" + principal10000);130 System.out.println("Rate: " + rate.multiply(new BigDecimal("100")) + "%");131 System.out.println("Years: " + years30);132 System.out.println("Amount: $" + amount.setScale(2, RoundingMode.HALF_UP));133}outputPrincipal: $10000 Rate: 5.00% Years: 30 Amount: $43219.42
@seealso biginteger_intro, math_functions
Exercise: Practical.java
Calculate compound interest and split a bill evenly among friends