Question

I have a scenario where I’m working with large integers (e.g. 160 bit), and am trying to create the biggest possible unsigned integer that can be represented with an n bit number at run time. The exact value of n isn’t known until the program has begun executing and read the value from a configuration file. So for example, n might be 160, or 128, or 192, etcetera…

Initially what I was thinking was something like:

BigInteger.valueOf((long)Math.pow(2, n));

but then I realized, the conversion to long that takes place sort of defeats the purpose, given that long is not comprised of enough bits in the first place to store the result. Any suggestions?

Answer 1

On the largest n-bit unsigned number

Let’s first take a look at what this number is, mathematically.

In an unsigned binary representation, the largest n-bit number would have all bits set to 1. Let’s take a look at some examples:

1₍₂₎= 1 =2¹ – 1
11₍₂₎= 3 =2² – 1
111₍₂₎= 7 =2³ – 1
:
1………1₍₂₎=2ⁿ -1
   ⁿ

Note that this is analogous in decimal too. The largest 3 digit number is:

10³- 1 = 1000 - 1 = 999

Thus, a subproblem of finding the largest n-bit unsigned number is computing 2ⁿ.

---

On computing powers of 2

Modern digital computers can compute powers of two efficiently, due to the following pattern:

2⁰= 1₍₂₎
2¹= 10₍₂₎
2²= 100₍₂₎
2³= 1000₍₂₎
:
2ⁿ= 10………0₍₂₎
       ⁿ

That is, 2ⁿ is simply a number having its bit n set to 1, and everything else set to 0 (remember that bits are numbered with zero-based indexing).

---

Solution

Putting the above together, we get this simple solution using BigInteger for our problem:

final int N = 5;
BigInteger twoToN   = BigInteger.ZERO.setBit(N);
BigInteger maxNbits = twoToN.subtract(BigInteger.ONE);

System.out.println(maxNbits); // 31

If we were using long instead, then we can write something like this:

// for 64-bit signed long version, N < 64
System.out.println(
    (1L << N) - 1
); // 31

There is no “set bit n” operation defined for long, so traditionally bit shifting is used instead. In fact, a BigInteger analog of this shifting technique is also possible:

System.out.println(
    BigInteger.ONE.shiftLeft(N).subtract(BigInteger.ONE)
); // 31

See also

• Wikipedia/Binary numeral system
• Bit Twiddling Hacks

---

Additional BigInteger tips

BigInteger does have a pow method to compute non-negative power of any arbitrary number. If you’re working in a modular ring, there are also modPow and modInverse.

You can individually setBit, flipBit or just testBit. You can get the overall bitCount, perform bitwise and with another BigInteger, and shiftLeft/shiftRight, etc.

As bonus, you can also compute the gcd or check if the number isProbablePrime.

ALWAYS remember that BigInteger, like String, is immutable. You can’t invoke a method on an instance, and expect that instance to be modified. Instead, always assign the result returned by the method to your variables.