Added files via upload

Integration Calculator v1.0

Integration/src/Integrate.java

@@ -0,0 +1,171 @@
+/**
+ * @author Simon O'Shea
+ */
+import java.text.DecimalFormat;
+import java.util.InputMismatchException;
+import java.util.NoSuchElementException;
+import java.util.Scanner;
+public class Integrate {
+	
+public static double functionValue(double A, double B, double C, double D, double E, double F, double x) {
+		
+		double value = 0;
+		
+		value = (A * Math.pow(x, 5)) + (B * Math.pow(x, 4)) + (C * Math.pow(x, 3)) + 
+					(D * (Math.pow(x, 2)) + (E * x) + F); 
+		
+		return value;
+		
+}
+	
+
+public static double antiDerivative(double A, double B, double C, double D, double E, double F, double a, double b) {
+	
+	A = A / 6.0; B = B / 5.0; C = C / 4.0; D = D / 3.0; E = E / 2.0;
+	
+	double first = (A * Math.pow(a, 6)) + (B * Math.pow(a, 5)) + (C * Math.pow(a, 4)) + (D * Math.pow(a, 3)) +
+					(E * Math.pow(a, 2)) + (F * a); 
+	
+	double last = (A * Math.pow(b, 6)) + (B * Math.pow(b, 5)) + (C * Math.pow(b, 4)) + (D * Math.pow(b, 3)) +
+			(E * Math.pow(b, 2)) + (F * b);  
+	
+
+	
+	return last - first;
+	
+}
+
+
+public static double midpointRule(double A, double B, double C, double D, double E, double F, double startInterval, double endInterval, double numInterval) {
+		
+		double sum = 0, temp;
+		double width = (endInterval - startInterval) / numInterval;
+		double start = startInterval + (width / 2.0);
+		
+		for(double i = start; i <= endInterval; i = i + width) {
+				
+				temp = functionValue(A, B, C, D, E, F, i);
+				sum += temp;
+				
+		}
+		
+	return sum * width;
+		
+}
+	
+
+public static double trapezoidRule(double A, double B, double C, double D, double E, double F, double startInterval, double endInterval, double numInterval) {
+	
+	double sum = 0, b1, b2;
+	double width = (endInterval - startInterval) / numInterval;	
+
+	for(double i = startInterval; i < endInterval; i = i + width) {
+		
+		
+		
+		b1 = functionValue(A, B, C, D, E, F, i);
+		b2 = functionValue(A, B, C, D, E, F, (i + width));
+		
+		
+		sum += (width * ((b1 + b2) / 2.0));
+		
+	}
+	
+	return sum;
+	
+}
+
+
+public static double simpsonsRule(double A, double B, double C, double D, double E, double F, double startInterval, double endInterval, double numInterval) {
+	
+	double mid = midpointRule(A, B, C, D, E, F, startInterval, endInterval, numInterval);
+	double trap = trapezoidRule(A, B, C, D, E, F, startInterval, endInterval, numInterval); 
+	
+	return ((2.0 * mid) + trap) / 3.0;
+	
+}
+
+		
+public static String percentError(double actual, double estimate) {
+	
+	double error = (estimate - actual) / actual;
+	
+	if(error == 0)
+		return "none";
+	
+	return String.format("%.9f %%", error);
+
+}
+
+
+public static void main(String[] args) {
+	Scanner input = new Scanner(System.in);
+	DecimalFormat formatter = new DecimalFormat("#,###.00");
+	
+	try {
+		System.out.println("Please enter the \"a\" bound of integration: ");
+			double a = input.nextDouble();
+			
+		
+		System.out.println("Please enter the \"b\" bound of integration: ");
+			double b = input.nextDouble();
+		
+			if(b < a) {
+				System.out.println("Error: \"a\" must be less than \"b\"");	
+				System.exit(0);
+			}
+		
+		System.out.println("Please enter the number of sub-intervals: ");
+			int n = input.nextInt();
+		
+			if(n <= 0) {
+				System.out.println("The amount of sub-intervals must be greater than or equal to 0.");
+				System.exit(0);
+			}
+		
+		System.out.println("Please enter 6 values: ");
+			double A = input.nextDouble();
+			double B = input.nextDouble();
+			double C = input.nextDouble();
+			double D = input.nextDouble();
+			double E = input.nextDouble();
+			double F = input.nextDouble();
+			input.close();
+		
+		System.out.printf("%n%n%nFunction being integrated: %.2fx^5 + %.2fx^4 + %.2fx^3 + %.2fx^2 + %.2fx + %.2f%n%n", A, B, C, D, E, F);
+			
+			Double actual = antiDerivative(A, B, C, D, E, F, a, b);
+			double midpoint = midpointRule(A, B, C, D, E, F, a, b, n);
+			double trapezoid = trapezoidRule(A, B, C, D, E, F, a, b, n);
+			double simpsons = simpsonsRule(A, B, C, D, E, F, a, b, n);
+			
+		
+		System.out.printf("-> The exact value (found by using the Fundamental Theorem of Calculus): %s   // error: %s%n%n", 
+																							formatter.format(actual), percentError(actual, actual));
+		
+		System.out.printf("-> The estimated value (found by using the Midpoint Reimann Sum method): %s   // error: %s%n%n", 
+																							formatter.format(midpoint), percentError(actual, midpoint));
+		
+		System.out.printf("-> The estimated value (found by using the Trapezoidal Reimann Sum method): %s   // error: %s%n%n", 
+																							formatter.format(trapezoid), percentError(actual, trapezoid));
+		
+		System.out.printf("-> The estimated value (found by using the Simpsons Reimann Sum method): %s   // error: %s%n%n", 
+																							formatter.format(simpsons), percentError(actual, simpsons));
+	}
+
+	catch(InputMismatchException x) {
+		
+		System.out.println("Error: Invalid input type");
+		System.exit(0);
+			
+	}
+	
+	catch(NoSuchElementException y) {
+		
+		System.out.println("Error: No input");
+		System.exit(0);
+		
+	}
+	
+}
+}