# 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 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 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 .