import org.apfloat.*;
import java.io.IOException;
import java.util.Scanner;
import java.io.File;
/**
 *
 * @author Jake Gunter
 */
public class PiChudnovskyMultithread {
    
    /**
     * the precision of the calculation; it is set later
     */
    static long precision = 1;
    
    /**
     * the scanner used throughout the program
     */
    Scanner in = new Scanner(System.in);
    
    /**
     * Pi, guaranteed correct (for testing purposes)
     */
    private String piCorrect;
    
    //simple constructor
    public PiChudnovskyMultithread() throws IOException {
        piCorrect = readPiFile();
    }
    
    public String readPiFile() throws IOException {
        Scanner fin = new Scanner(new File("pi.txt"));
        String piTmp = "";
        while(fin.hasNext()) 
            piTmp += fin.nextLine();
        return piTmp;
    }
    public void validatePi(Apfloat pi) {
        String piStr = pi.toString(true);
        int smallerLen = piStr.length() < piCorrect.length() ? piStr.length() : piCorrect.length();
        int digitsCorrect = 0;
        String userPiCorrect = "";
        for(int i=0;i<smallerLen;i++) {
            char correct = piCorrect.charAt(i);
            char user = piStr.charAt(i);
            if (correct == user) {
                digitsCorrect++;
                userPiCorrect += user;
            }
            else break;
        }
        System.out.println(digitsCorrect-1 + " digits correct:");
        System.out.println(userPiCorrect);
    }
    public static Apfloat factorial(Apfloat num) {
        if (num.compareTo(new Apfloat(0)) == 0) return Apfloat.ONE;
        Apfloat factorialized = num;
        for(Apfloat i=num;i.compareTo(new Apfloat(0))>0;i=i.subtract(new Apfloat(1))) {
            Apfloat x = i.compareTo(new Apfloat(1)) == 0 ? new Apfloat(0) : new Apfloat(1);
            factorialized = factorialized.multiply(i.subtract(x));
        }
        return factorialized;
    }
    public static Apfloat inverse(Apfloat num) {
        return new Apfloat(1).divide(num);
    }
    public static Apfloat negpow(Apfloat a, Apfloat b) {
        if(b.mod(new Apfloat(2)).intValue() == 0) {
            return ApfloatMath.pow(a.negate(),b);
        }
        else return ApfloatMath.pow(a.negate(), b).negate();
    }
    
    /**
     * This method handles the thread scheduling and the final summation of pi.
     * First, it checks the number of available processors with a call to
     * <code>Runtime.getRuntime().availableProcessors()</code>. Then it creates
     * an array of {@link chudThread} that will do the actual calculation.
     * <p>
     * Based on a user input of the number of iterations, it spreads that out
     * over all available <code>chudThread</code>, and sets the field <code>
     * precision</code> according to the number of calculations.
     * It also times the calculation.
     * <p>
     * After all threads have finished calculating, it sums the partial sums,
     * and carries out the final steps needed to calculate pi. Then it displays
     * pi, along with the amount of time taken for the calculation.
     * 
     * @throws java.lang.InterruptedException
     * @throws java.io.IOException
     */
    public void calculatePi() throws InterruptedException, IOException {
        int numProcs = Runtime.getRuntime().availableProcessors();
        chudThread[] calculators = new chudThread[numProcs];
        long start = 0;
        System.out.print("How many iterations? ");
        int procMult = Integer.parseInt(in.nextLine()) / numProcs;
        while (procMult <= 0) {
            System.out.println("That's not a valid number of iterations!");
            System.out.print("How many iterations? ");
            procMult = (in.nextInt()) / numProcs;
        }
        precision = procMult * numProcs * 14 + 1 + (procMult * numProcs)/10;
        System.out.println(precision);
        for(int i=0;i<numProcs;i++) {
            calculators[i] = new chudThread(start, start+=procMult);
        }
        System.out.println("Calculating...");
        long startTime = System.currentTimeMillis();
        for(int i=0;i<numProcs;i++) {
            calculators[i].start();
        }
        for(int i=0;i<numProcs;i++) {
            calculators[i].join();
        }
        Apfloat pi = new Apfloat(0,precision);
        for (int i=0;i<numProcs;i++) {
            pi = pi.add(calculators[i].piPart);
        }
        pi = pi.multiply(new Apfloat(12,precision));
        pi = inverse(pi);
        new PiChudnovskyMultithread().validatePi(pi);
        long endTime = System.currentTimeMillis();
        System.out.println("Calculation took " + ((double)(endTime - startTime) / 1000) + " seconds.");
    }
    
    /**
     * This subclass is the thread that calculates a partial sum of pi from a
     * specified start iteration to a specified end iteration. The calculation
     * loop algorithm is based on the Chudnovsky brothers' formula for pi.
     */
    static class chudThread extends Thread {
        /**
         * This thread's partial sum
         */
        private Apfloat piPart = new Apfloat(0,precision);
        
        /**
         * the start iteration (inclusive)
         */
        private long start;
        
        /**
         * the end iteration (exclusive)
         */
        private long end;
        
        /**
         * The constructor.
         * 
         * @param startI the starting iteration
         * @param endI the ending iteration
         */
        public chudThread(long startI, long endI) {
            start = startI;
            end = endI;
        }
        /**
         * This method sums pi from the start iteration to the end iteration.
         * It stores the result in the field <code>piPart</code>.
         */
        @Override
        public void run() {
            Apfloat x = new Apfloat(0,precision);
            Apfloat y = new Apfloat(0,precision);
            Apfloat a = new Apfloat(0,precision);
            Apfloat b = new Apfloat(0,precision);
            Apfloat c = new Apfloat(0,precision);
            Apfloat bn1 = new Apfloat(-1,precision);
            Apfloat b6 = new Apfloat(6,precision);
            Apfloat b13591409 = new Apfloat(13591409,precision);
            Apfloat b545140134 = new Apfloat(545140134,precision);
            Apfloat b3 = new Apfloat(3,precision);
            for(Apfloat i=new Apfloat(start,precision);i.compareTo(new Apfloat(end,precision))<0;i=i.add(new Apfloat(1))) {
                 a = negpow(bn1,i);
                 b = factorial((b6.multiply(i)));
                 c = b13591409.add(b545140134.multiply(i));
                 x = a.multiply(b.multiply(c));
                 a = factorial(b3.multiply(i));
                 b = ApfloatMath.pow(factorial(i),3);
                 c = new Apfloat(3.0/2.0,precision).add(new Apfloat(3,precision).multiply(i));
                 y = a.multiply(b).multiply(ApfloatMath.pow(new Apfloat(640320,precision),c));
                 piPart = piPart.add(x.divide(y));
            }
        }
    }
    public static void main(String[] args) throws InterruptedException, IOException {
        new PiChudnovskyMultithread().calculatePi();
    }
}