#41 Add parallel trapezoid rule example

Author: pockerman

README.md

@@ -54,7 +54,8 @@ This is my  Java playground...
 
 ### Java Threads
 
-- <a href="src/main/java/applications/threading/SumArrayElements.java">Example 1</a>: Get the sum of the elements of an array
+- <a href="src/main/java/applications/threading/Example1.java">Example 1</a>: Get the sum of the elements of an array
+- <a href="src/main/java/applications/threading/Example2.java">Example 2</a>: Parallel trapezoid rule
 
 ## Useful Links
 

src/main/java/applications/threading/Example2.java

@@ -0,0 +1,115 @@
+package applications.threading;
+
+import utils.IActor;
+import utils.Pair;
+import utils.PairBuilder;
+
+/**
+ * Category: Threading
+ * ID: Example2
+ * Description: Implement trapezoid rule in action
+ * Taken From: Code from the book Modern Java in Action 2nd Edition
+ *
+ * Details:
+ *
+ *
+ */
+
+public class Example2 {
+
+    public static IActor<Double, Double> f = (Double a)->{return a*a;};
+
+    class LocalIntegrator implements Runnable{
+
+
+        public LocalIntegrator(Pair<Integer, Integer> range, double start, double h){
+
+            this.range = range;
+            this.start = start;
+            this.h = h;
+            this.localSum = 0.0;
+        }
+
+        @Override
+        public void run() {
+
+            for(int i= range.first; i< range.second; ++i){
+                localSum += Example2.f.evaluate(start + i*h);
+            }
+        }
+
+        public double getLocalSum(){
+            return localSum;
+        }
+
+        private Pair<Integer, Integer> range;
+        private double start;
+        private double h;
+        private double localSum;
+    }
+
+
+    public static void main(String[]  args) throws InterruptedException{
+
+        // start interval
+        double a = 0.0;
+
+        // end interval
+        double b = 1.0;
+
+        // how many intervals
+        int n = 200;
+
+        // the discretization size
+        double h = (b-a)/n;
+
+        System.out.println("Discretization size: " + h);
+
+        // number of threads
+        int numTreads = 4;
+
+        int localWorkSize = n/numTreads;
+
+        System.out.println("Local work size: " + localWorkSize);
+
+        // calculate the intervals
+        Pair<Integer, Integer> range1 = PairBuilder.makePair(1, localWorkSize);
+        Pair<Integer, Integer> range2 = PairBuilder.makePair(localWorkSize, 2*localWorkSize);
+        Pair<Integer, Integer> range3 = PairBuilder.makePair(2*localWorkSize, 3*localWorkSize);
+        Pair<Integer, Integer> range4 = PairBuilder.makePair(3*localWorkSize, 4*localWorkSize);
+
+        // create the workers
+
+        Example2 example2 = new Example2();
+
+        LocalIntegrator integrator1 = example2.new LocalIntegrator(range1, a, h);
+        LocalIntegrator integrator2 = example2.new LocalIntegrator(range2, a, h);
+        LocalIntegrator integrator3 = example2.new LocalIntegrator(range3, a, h);
+        LocalIntegrator integrator4 = example2.new LocalIntegrator(range4, a, h);
+
+        Thread t1 = new Thread( integrator1 );
+        Thread t2 = new Thread(integrator2 );
+        Thread t3 = new Thread(integrator3 );
+        Thread t4 = new Thread(integrator4 );
+
+        t1.start();
+        t2.start();
+        t3.start();
+        t4.start();
+
+        double sum = Example2.f.evaluate(a) * 0.5;
+
+        t1.join();
+        t2.join();
+        t3.join();
+        t4.join();
+
+        sum += integrator1.getLocalSum();
+        sum += integrator2.getLocalSum();
+        sum += integrator3.getLocalSum();
+        sum += integrator4.getLocalSum();
+        sum += Example2.f.evaluate(b) * 0.5;
+
+        System.out.println("Integral calculated: "+sum*h);
+    }
+}