
How many Java programmers does it take to round up to a power of two? - nickb
http://forum.java.sun.com/thread.jspa?threadID=248212&start=0&tstart=0
======
asmosoinio
Funny thread! :)

I guess the thing here is that bit operators are not really "in you face" in
Java. If you are programming in assembler, or even C, bits will be what you
know. Programming at a higher level, you may not be that aware of bit
functions and how to use them in real life. You should, but many are not.

The second approach by gojomo here is neat and effective and works directly at
the bits instead of bloating with creating Strings and other objects for this
simple task. So it's not the fault of the tool, it about the abstraction level
people are thinking in.

~~~
lisporama
What are the bit operators in Common Lisp? My google-fu fails me...

~~~
shiro
CL has logand, logior, logxor, lognot, etc. It also has a parameterized
version, boole <http://www.lisp.org/HyperSpec/Body/fun_boole.html>

------
tmm1
<http://pastie.caboo.se/113312>

~~~
tallpapab
You have an infinite loop when i < 2^30.

    
    
      static int nextOne(int theInt) {
        int answer = 1;
        while (answer < theInt && 0 < answer) {
          answer <<= 1;
        }
        if (answer < 1) {
          throw new IllegalArgumentException("Sorry, " +
            theInt + " is bigger than 2 to the power of 30 (1073741824).");
        }
        return answer;
      }
    

~~~
gojomo
Good point. (And, as your signature indicates, this _is_ more likely to be a
static utility method.)

If I were defensively programming against unanswerable input, I'd tend towards
failing fast with a single early check:

    
    
     static int roundUpToPowerOfTwo(int i) {
      if(i>(1<<30)) throw new IllegalArgumentException("Answer overflows int");
      int rounded = 1;
      while(rounded<i) rounded <<= 1; 
      return rounded;
     }
    

If we needed to give answers for any size integer (or at least up to
2^(2^31-1)), we could use BigInteger, whose #bitLength method is useful:

    
    
      static BigInteger roundUpToPowerOfTwo(BigInteger i) {
       return BigInteger.ONE.shiftLeft(i.subtract(BigInteger.ONE).bitLength());
      }
    

And if we weren't being literal-minded about the original request, it might
make sense to just return the exponent rather than the power-of-2 itself, and
let the caller worry about overflows:

    
    
     static int ceilLog2(long val) {
      return BigInteger.valueOf(val-1).bitLength();
     }
    

Of course we are ignoring negative exponents, in the integer spirit of the
original question.

There, is it done to death yet? :)

------
lisporama
Here is a mediocre lisper and an advanced lisper's take on the question (edit:
and also _another_ lisper's take, too):

[http://lispy.wordpress.com/2007/11/02/my-solution-to-the-
rou...](http://lispy.wordpress.com/2007/11/02/my-solution-to-the-rounding-up-
to-the-nearst-power-of-two/)

