When would you use object BigInteger instead of simply using double?

Question

So I was given a problem telling me to make a table of factorials of integers up to number 30. The book specifically tells me to use the object BigInteger. (using BigInteger big= BigInteger.valueOf(x)) However doing so is pretty tricky and gives me a bunch of errors that I have no idea how to fix.

for example

public static BigInteger factorial(int a){
        if(a == 0){
            return BigInteger.valueOf(1);
        }
        else{
            return BigInteger.valueOf(a*BigInteger.valueOf(factorial(a-1)));// this will keep giving me an error message that I need to change the value type to "long" and back and forth to BIgInteger.  I've tried many different variations including where I use BigInteger.valueOf(..) to every values.
        }

    }

Do you know a correct way to use the BigInteger object?

When would you ever use BigInteger instead of double?

   import java.math.BigInteger;
        public class BigInt {

            public static double factorial(int a){
                if(a == 0){
                    return 1;
                }
                else{
                    return a* factorial(a-1);
                }

            }
            public static void table(int a){
                for(int i =0; i<=a; i++){
                    System.out.println(i + ", " + factorial(i) );

                    }
                }

            public static void main(String[] args) {
            table(30);
            }

        }

score 1 · Answer 1 · answered Nov 02 '15 at 07:20

1

Instead of

BigInteger.valueOf(a*BigInteger.valueOf(factorial(a-1)))

try

factorial(a - 1).multiply(BigInteger.valueOf(a))

You are currently trying to use the * operator to multiply an int and BigInteger; that isn't allowed in Java, since operator overloading isn't supported.

As to why you'd use BigInteger instead of double: double only supports a finite number of significant figures before it starts rounding. Using BigInteger allows you to have arbitrarily-large numbers.

answered Nov 02 '15 at 07:20

Andy Turner

137,514
11
162
243

Oh I get it. It's not a primitive type so * doesn't work. – user87902 Nov 02 '15 at 07:22
So when would you use BigInteger instead of double? – user87902 Nov 02 '15 at 07:22

Eran · Accepted Answer · 2015-11-02T07:26:04.480

1

When you are using BigInteger you can't use operators such as *. You must use methods of the BigInteger class :

return factorial(a-1).multiply(a);

The reason for using BigInteger instead of double is precision. double has limited precision, so large integers can't be represented accurately.

EDIT: You should actually use

return BigInteger.valueOf(a).multiply(factorial(a-1));

since BigInteger multiply(long v) is package private.

edited Nov 02 '15 at 07:26

answered Nov 02 '15 at 07:22

Eran

387,369
54
702
768

... and because it's useful to make it clear that you're representing *integers* rather than arbitrary rational numbers... – Jon Skeet Nov 02 '15 at 07:23
I don't see `multiply(int)` or `multiply(long)` in the [Javadoc](https://docs.oracle.com/javase/7/docs/api/java/math/BigInteger.html#multiply(java.math.BigInteger)). – Andy Turner Nov 02 '15 at 07:24

score 0 · Answer 3 · edited May 23 '17 at 12:14

0

It's not a primitive type so * doesn't work. For detail description read this article, A brief description about use of object BigInteger. I Hope it will help you a lot. Java:Why should we use BigDecimal instead of Double in the real world?

edited May 23 '17 at 12:14

Community

1
1

answered Nov 02 '15 at 07:25

Asad

498
7
21

score 0 · Answer 4 · answered Nov 02 '15 at 09:07

When we deal with numbers related to money , where we require results in nearest precision . Then we use BigInteger instead of double. But comparing with double , Big Integer is slow in performance as internally BigInteger requires more number of operators for processing. I recommend use of javadoc (http://docs.oracle.com/javase/1.5.0/docs/api/java/math/BigDecimal.html).

score 0 · Answer 5 · answered Nov 02 '15 at 09:14

0

Using BigInteger is also necessary when performing numerical calculations with large integers for e.g. Cryptographic purposes. The rounding used on floats or doubles would make applying the theories underlying these Cryptographic methods impossible.

answered Nov 02 '15 at 09:14

Mathieu Borderé

4,357
2
16
24

When would you use object BigInteger instead of simply using double?

5 Answers5