Inital commit

Author: skrustev

.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="lib" path="lib/apfloat.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>PI_Ramanujan2_swing</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8

Pi_Calculation_Ramanujan.docx

@@ -0,0 +1 @@
+3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360011330530548820466521384146951941511609433057270365759591953092186117381932611793105118548074462379962749567351885752724891227938183011949129833673362440656643086021394946395224737190702179860943702770539217176293176752384674818467669405

bin/main/App$1.class

@@ -0,0 +1,103 @@
+package main;
+
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.PrintWriter;
+import java.rmi.RemoteException;
+import java.util.concurrent.ExecutionException;
+
+import main.Rumanujan2Pi;
+import main.Calculator;
+import main.CustomMath;
+import main.Task;
+import main.TaskResult;
+import main.Task;
+
+import javax.swing.SwingUtilities;
+
+import main.GUI.MainFrame;
+
+import org.apfloat.Apfloat;
+
+public class App {
+
+	public static boolean quiet = false;
+
+	public static void main(String[] args) throws FileNotFoundException,
+			InterruptedException, ExecutionException, RemoteException {
+
+		int numThreads = 1, numTerms = 100;
+		String outFile = "pi";
+
+		for (int i = 0; i < args.length; i++) {
+			String arg = args[i];
+
+			if (arg.equals("-p") || arg.equals("--terms")) {
+				numTerms = Integer.parseInt(args[i + 1]);
+				i++;
+			} else if (arg.equals("-t") || arg.equals("--threads")) {
+				numThreads = Integer.parseInt(args[i + 1]);
+				i++;
+			} else if (arg.equals("-o") || arg.equals("--out")) {
+				outFile = args[i + 1];
+				i++;
+			} else if (arg.equals("-q") || arg.equals("--quiet")) {
+				quiet = true;
+			} else {
+				System.err.println("Unknown option " + arg);
+				System.exit(1);
+			}
+		}
+
+		if (numTerms == 0) {
+			System.err.println("Number of terms should be specified with -p");
+			System.exit(1);
+		}
+
+		if (numThreads == 0) {
+			numThreads = Runtime.getRuntime().availableProcessors();
+			System.out.println("Using " + numThreads + " threads");
+		}
+
+		Rumanujan2Pi sum = new Rumanujan2Pi(numTerms, quiet);
+		if (quiet) {
+			CaltulatePi(sum, numTerms, numThreads, outFile);
+		} else {
+			final int numTermsF = numTerms;
+			final int numThreadsF = numThreads;
+			final String outFileF = outFile;
+			
+			SwingUtilities.invokeLater(new Runnable() {
+				public void run() {
+					new MainFrame(numTermsF, numThreadsF, outFileF);
+				}
+			});
+		}
+
+	}
+
+	private static void CaltulatePi(Rumanujan2Pi sum, int numTerms,
+			int numThreads, String outFile) throws FileNotFoundException,
+			InterruptedException, ExecutionException, RemoteException {
+
+		long startTime, timeToCompute;
+		
+		Calculator calculator = new Calculator(numThreads);
+		TaskResult result;
+		Apfloat pi;
+
+		startTime = System.currentTimeMillis();
+		result = calculator.calculate(sum, numTerms);
+		pi = sum.roundPiSum(result);
+		timeToCompute = System.currentTimeMillis() - startTime;
+		calculator.shutdown();
+
+		System.out.println("Time to complete: " + timeToCompute + "ms");
+
+		PrintWriter file = new PrintWriter(new FileOutputStream(outFile, false));
+		file.println(pi.toString());
+		file.flush();
+		file.close();
+
+	}
+}

bin/main/App.class

@@ -0,0 +1,105 @@
+package main;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import org.apfloat.Apfloat;
+
+/* Main thread operator */
+//Controls the threads, the desired calculator is split into
+
+public class Calculator {
+	private List<Task> tasks;
+	private ExecutorService executor;
+	private int numThreads;
+
+	public Calculator(int numThreads) {
+		this.numThreads = numThreads;
+		tasks = new ArrayList<Task>(numThreads);
+		this.executor = Executors.newFixedThreadPool(numThreads);
+	}
+
+	Calculator(int numThreads, int maxNumThreadsAtOnce) {
+		tasks = new ArrayList<Task>(numThreads);
+		this.executor = Executors.newFixedThreadPool(maxNumThreadsAtOnce);
+	}
+
+	public TaskResult calculate(Rumanujan2Pi sum, int numTerms)
+			throws InterruptedException, ExecutionException {
+
+		distributeTaskTerms(numTerms);
+		final List<Future<TaskResult>> futureResults = new ArrayList<Future<TaskResult>>(
+				tasks.size());
+
+		for (int i = 0; i < tasks.size(); i++) {
+			Task taskToCall = tasks.get(i);
+			
+			Callable<TaskResult> callableTask = new Callable<TaskResult>() {
+				@Override
+				public TaskResult call() throws Exception {
+					return taskToCall.calculate(sum);
+				}
+			};
+
+			futureResults.add(executor.submit(callableTask));
+
+		}
+
+		List<TaskResult> finalResults = waitAndGetAllResults(futureResults);
+
+		return combineSums(finalResults);
+	}
+
+	private void distributeTaskTerms(int numTerms) {
+		int numTermsLeft = numTerms;
+		int termsAssigned = numTerms / numThreads;
+		int startIndex = 0;
+
+		for (int i = 0; i < numThreads - 1; i++) {
+			tasks.add(new Task(i, startIndex, termsAssigned));
+			startIndex += termsAssigned;
+			numTermsLeft -= termsAssigned;
+		}
+
+		tasks.add(new Task(numThreads - 1, startIndex, numTermsLeft));
+	}
+
+	private List<TaskResult> waitAndGetAllResults(
+			List<Future<TaskResult>> futureResults)
+			throws InterruptedException, ExecutionException {
+
+		List<TaskResult> results = new ArrayList<TaskResult>(
+				futureResults.size());
+
+		for (int i = 0; i < futureResults.size(); i++) {
+			results.add(futureResults.get(i).get());
+		}
+
+		return results;
+	}
+
+	private TaskResult combineSums(List<TaskResult> results) {
+		Apfloat sum = Apfloat.ZERO;
+		Apfloat lastPartialTerm = Apfloat.ONE;
+		int termCount = 0;
+
+		for (TaskResult partialResult : results) {
+			sum = sum.add(lastPartialTerm.multiply(partialResult.getSum()));
+
+			lastPartialTerm = lastPartialTerm.multiply(partialResult
+					.getLastPartialTerm());
+			termCount += partialResult.getNumTerms();
+		}
+
+		return new TaskResult(sum, lastPartialTerm, termCount, 1);
+	}
+
+	public void shutdown() {
+		executor.shutdown();
+	}
+}

bin/main/Calculator$1.class

@@ -0,0 +1,25 @@
+package main;
+import org.apfloat.Apfloat;
+
+public class CustomMath {
+	public static Apfloat fact(int num) {
+		if (num == 0) {
+			return Apfloat.ONE;
+		}
+
+		return fact2(1, num);
+	}
+
+	public static Apfloat fact2(int from, int to) {
+		if (from == to) {
+			return new Apfloat(from);
+		}
+
+		int middle = (from + to) / 2;
+		Apfloat a = fact2(from, middle);
+		Apfloat b = fact2(middle + 1, to);
+
+		return a.multiply(b);
+	}
+
+}

bin/main/Calculator.class

@@ -0,0 +1,24 @@
+package main.GUI;
+import java.util.EventObject;
+
+import javax.swing.JProgressBar;
+
+
+public class DetailEvent extends EventObject{
+	private int[] details;
+	JProgressBar[] progressBars;
+	
+	public DetailEvent(Object source, int[] details,JProgressBar[] progressBars) {
+		super(source);
+		this.details = details;
+		this.progressBars = progressBars;
+	}
+	
+	public int[] getDetails() {
+		return details;
+	}
+	
+	public JProgressBar[] getProgressBars() {
+		return progressBars;
+	}
+}

bin/main/CustomMath.class

@@ -0,0 +1,8 @@
+package main.GUI;
+
+import java.util.EventListener;
+
+public interface DetailListener extends EventListener {
+	public void detailEventOccured(DetailEvent event);
+
+}