Big Numbers

Big Numbers

If the precision of the basic integer and floating-point types is not sufficient, you can turn to a couple of handy classes in the java.math package: BigInteger and BigDecimal . These are classes for manipulating numbers with an arbitrarily long sequence of digits. The BigInteger class implements arbitrary precision integer arithmetic, and BigDecimal does the same for floating-point numbers.

Use the static valueOf method to turn an ordinary number into a big number:

BigInteger a = BigInteger.valueOf(100);

Unfortunately, you cannot use the familiar mathematical operators such as + and * to combine big numbers. Instead, you must use methods such as add and multiply in the big number classes.

BigInteger c = a.add(b); // c = a + b
BigInteger d = c.multiply(b.add(BigInteger.valueOf(2))); // d = c * (b + 2)

C++ NOTE

Unlike C++, Java has no programmable operator overloading. There was no way for the programmer of the BigInteger class to redefine the + and * operators to give the add and multiply operations of the BigInteger classes. The language designers did overload the + operator to denote concatenation of strings. They chose not to overload other operators, and they did not give Java programmers the opportunity to overload operators themselves .

Example 3-6 shows a modification of the lottery odds program of Example 3-5, updated to work with big numbers. For example, if you are invited to participate in a lottery in which you need to pick 60 numbers out of a possible 490 numbers, then this program will tell you that your odds are 1 in 716395843461995557415116222540092933411717612789263493493351013459481104668848. Good luck!

The program in Example 3-5 computed the statement:

lotteryOdds = lotteryOdds * (n - i + 1) / i;

When big numbers are used, the equivalent statement becomes:




lotteryOdds = lotteryOdds.multiply(BigInteger.valueOf(n - i + 1)).divide(BigInteger

.valueOf(i));

Example 3-6. BigIntegerTest.java

1. import java.math.*;
 2. import java.util.*;
 3.
 4. public class BigIntegerTest
 5. {
 6.    public static void main(String[] args)
 7.    {
 8.       Scanner in = Scanner.create(System.in);
 9.
10.       System.out.print("How many numbers do you need to draw? ");
11.       int k = in.nextInt();
12.
13.       System.out.print("What is the highest number you can draw? ");
14.       int n = in.nextInt();
15.
16.       /*
17.          compute binomial coefficient
18.          n * (n - 1) * (n - 2) * . . . * (n - k + 1)
19.          -------------------------------------------
20.          1 * 2 * 3 * . . . * k
21.       */
22.
23.       BigInteger lotteryOdds = BigInteger.valueOf(1);
24.
25.       for (int i = 1; i <= k; i++)
26.          lotteryOdds = lotteryOdds
27.             .multiply(BigInteger.valueOf(n - i + 1))
28.             .divide(BigInteger.valueOf(i));
29.
30.       System.out.println("Your odds are 1 in " + lotteryOdds +
31.         ". Good luck!");
32.    }
33. }



java.math.BigInteger 1.1

BigInteger add(BigInteger other)
BigInteger subtract(BigInteger other)
BigInteger multiply(BigInteger other)
BigInteger divide(BigInteger other)
BigInteger mod(BigInteger other)

return the sum, difference, product, quotient , and remainder of this big integer and other .
int compareTo(BigInteger other)

returns 0 if this big integer equals other , a negative result if this big integer is less than other , and a positive result otherwise .
static BigInteger valueOf(long x)

returns a big integer whose value equals x .



java.math.BigDecimal 1.1

BigDecimal add(BigDecimal other)
BigDecimal subtract(BigDecimal other)
BigDecimal multiply(BigDecimal other)
BigDecimal divide(BigDecimal other, RoundingMode mode) 5.0

return the sum, difference, product, or quotient of this big decimal and other . To compute the quotient, you must supply a rounding mode . The mode RoundingMode.HALF_UP is the rounding mode that you learned in school (i.e., round down digits 0 . . . 4, round up digits 5 . . . 9). It is appropriate for routine calculations. See the API documentation for other rounding modes.
int compareTo(BigDecimal other)

returns 0 if this big decimal equals other , a negative result if this big decimal is less than other , and a positive result otherwise.
static BigDecimal valueOf(long x)
static BigDecimal valueOf(long x, int scale)

return a big decimal whose value equals x or x / 10 ^scale .