leetcode pow

public class Pow {
//	//recursive version
//	//stack overflow when n is large
//    public double pow(double x, int n) {
//        
//    	if(n < 0) {
//    		return 1.0/pow(x, -n);
//    	}
//    	
//    	if(n == 0) return 1;
//    	if(n == 1) return x;
//    	
//    	return x * pow(x, n-1);
//    }

//	//divide and conquer
//	//exceeds the time limit
//    public double pow(double x, int n) {
//        
//    	if(n < 0) {
//    		return 1.0/pow(x, -n);
//    	}
//    	
//    	if(n == 0) return 1;
//    	if(n == 1) return x;
//    	
//    	double half = pow(x, n/2);
//    	
//    	if(n % 2 == 0) {
//    		return half * half;
//    	} else {
//    		return half * half *x;
//    	}
//    }
	
	/*
	 * Binary Operation
	Consider the binary representation of n. For example, 
	if it is "10001011", then x^n = x^(1+2+8+128) = x^1 * x^2 * x^8 * x^128. 
	Thus, we don't want to loop n times to calculate x^n. 
	To speed up, we loop through each bit, if the i-th bit is 1, 
	then we add x^(1 << i) to the result. 
	Since (1 << i) is a power of 2, x^(1<<(i+1)) = square(x^(1<<i)). 
	The loop executes for a maximum of log(n) times.
	*/
	
    public double pow(double x, int n) {
    	int m;
    	if(n < 0)  m = -n ; 
    	else m = n;
    	
    	double r = 1;
    	for( ; m > 0; x*=x, m = m>>1) {
    		if( (m & 1) != 0) {
    			r *= x;
    		}
    	}
    	
    	if(n >= 0) return r;
    	else return 1./r;
    }
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Pow p = new Pow();
		System.out.println(p.pow(1.00000, -2147483648));
	}
}