/*
 * Timing.java
 * 	This class estimates the exponent of our
 * 	implementation of Karatsuba 's algorithm
 *	and also Java's multiplication.
 *
 * @author Chee Yap
 * Basic Algorithms, Fall 2005
 */


import java.math.*;
import java.util.Random;

public class Timing {
	
	//default parameters:
	public static int noPoints=10, stepSize=50, startSize=200, noTrials=50; 
	 
	public static void main(String[] args) {
		
		BigInteger X,Y,Z;
		int size=0;
		double log_Tn,log_n;
		
		switch(args.length){
			case 4:	
				noTrials=Integer.parseInt(args[3]);				
			case 3:	
				startSize=Integer.parseInt(args[2]);			
			case 2: 
				stepSize=Integer.parseInt(args[1]);
			case 1: 
				noPoints=Integer.parseInt(args[0]);
				break;	
			default: System.out.println("NOTE: DEFAULT values are being used");
		}
		Random rnd = new Random ();

		double [] x_arr= new double [noPoints];		//holds log_n values
		double [] y_arr= new double [noPoints];		//holds log_Tn values
		double [] results = new double [2];		
		
		for(int i=0;i<noPoints;i++){	
			X= new BigInteger (startSize+size, rnd);
			Y= new BigInteger (startSize+size, rnd);
			long startTime=System.currentTimeMillis();
			for(int j=0;j<noTrials;j++)	
				Z=Karat.mult(X,Y);		// Calls Karatsuba multiplication!!!
			long endTime=System.currentTimeMillis();
			
			log_Tn=Math.log( (double)(endTime-startTime)/noTrials );
			log_n=Math.log((double)find_n(X,Y));
			x_arr[i]=log_n;
			y_arr[i]=log_Tn;
			size+=stepSize;	
		}
		
		results=fitLine(x_arr,y_arr);
		System.out.println("Here are the values :");
		System.out.println(" exponent= "+results[1]+",constant= "+Math.exp(results[0]));

	}//end of main
	
	// find_n finds the max number of bits needed to represent X or Y
	// Returns the maximum bitLength or bitLength+1 if the number of bits is odd
	public	static int find_n (BigInteger X,BigInteger Y){
		int sh_nb;
		
      		if(X.bitLength()>Y.bitLength())		
      			sh_nb=X.bitLength();
      		else
      			sh_nb=Y.bitLength();
      		if((sh_nb%2)!=0)
      			sh_nb++;		
		return sh_nb;
	}//end of find_n


/*
 * code for fitLine
 * @author Chee Yap
 * Honors Basic Algorithms, Fall 2000
 */

   // scalar product of two vectors:

   public static double scalar (double[] X, double[] Y)
   {
     double s = 0;
     for (int i=0; i< X.length; i++) 
	s += X[i]* Y[i];
     return s;
   }

   // computes a 2x2 matrix based on 2 input basis vectors (phi0, phi1):

   public static double[][] matrix (double[] phi0, double[] phi1)
   {
     double[][] m = new double[2][2];
     m[0][0] = scalar(phi0, phi0);
     m[0][1] = m[1][0] = scalar(phi0, phi1);
     m[1][1] = scalar(phi1, phi1);
     return m;
   }
     
   // computes determinant of a 2x2 matrix:

   public static double det (double[][] m)
   {
     return (( m[0][0]*m[1][1] ) - ( m[0][1]* m[1][0] ));
   }

   /**
    * fitLine computes the least squares best fit line (a+bX) for a function
    * where the (discrete) function is given by lX and lY
    * @param lX is a vector of some length n
    * @param lY is a vector of the same length n
    * @returns [a,b] representing the the least-squares line (a+bX)
    */

    public static double[] fitLine(double[] lX, double [] lY) {

	int n = lX.length;

	double[] l1 = new double[n];
	for (int i=0; i<n; i++)
		l1[i] = 1;

	double[][] m = matrix(l1, lX);

        double d = det(m);

        double c0 = scalar(l1, lY);
        double c1 = scalar(lX, lY);

	double[] r = new double[2];
	r[0] = ((   m[1][1] * c0 ) - ( m[0][1] * c1 ))/d;
	r[1] = (( - m[1][0] * c0 ) + ( m[0][0] * c1 ))/d;

	return r;
    } // fitLine

}//end of class