misc

documents/Programmierparadigmen/scripts/java/MultipleCorePrimeTest.java

@@ -0,0 +1,78 @@
+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.FutureTask;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+public class MultipleCorePrimeTest {
+    public static void count(int target, int threads) 
+      throws InterruptedException, TimeoutException {
+        ExecutorService executor =
+            Executors.newFixedThreadPool(threads);
+        List<FutureTask<Integer>> taskList = 
+            new ArrayList<FutureTask<Integer>>();
+        long startTime = System.currentTimeMillis();
+
+        for (int i = 1; i <= threads; ++i) {
+            int ilen = target / threads;
+
+            /* Test following intervall for primes */
+            final int start = (i - 1) * ilen;
+            final int end = (i != threads) 
+                            ? i * ilen - 1 
+                            : target;
+            FutureTask<Integer> task = 
+                new FutureTask<Integer>(
+                  new Callable<Integer>() {
+                    @Override
+                    public Integer call() {
+                        int count = 0;
+                        for (int i = start; i <= end; 
+                                            ++i) {
+                            if (SingleCorePrimeTest.
+                                  isPrime(i))
+                                ++count;
+                        }
+                        return count;
+                    }
+                });
+            taskList.add(task);
+            executor.submit(task);
+        }
+
+        executor.shutdown();
+        if (!executor.awaitTermination(10, 
+            TimeUnit.MINUTES)) {
+                throw new TimeoutException();
+        }
+        final long endTime = System.currentTimeMillis();
+        int count = 0;
+        for (int i = 0; i < taskList.size(); ++i) {
+            try {
+                count += taskList.get(i).get();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            } catch (ExecutionException e) {
+                e.printStackTrace();
+            }
+        }
+        System.out.println(threads + " thread: "
+            + (endTime - startTime) + " ms");
+    }
+
+    public static void main(String[] args) {
+        final int target = 100_000_000;
+        try {
+            count(target, 1);
+            count(target, 2);
+            count(target, 4);
+            count(target, 8);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

documents/Programmierparadigmen/scripts/java/SieveOfErasthostenes.java

@@ -0,0 +1,27 @@
+import java.util.Arrays;
+
+public class SieveOfErasthostenes {
+
+    public static boolean[] sieveIt(int n) {
+        boolean[] sieve = new boolean[n+1];
+        Arrays.fill(sieve, true);
+        sieve[0] = false;
+        sieve[1] = false;
+        for (int i=2; i <= Math.sqrt(n); i++) {
+            if (sieve[i]) {
+                for (int c = i*i; c <= n; c += i) {
+                    sieve[c] = false;
+                }
+            }
+        }
+        return sieve;
+    }
+
+    public static void main(String[] args) {
+        final int n = 100_000_000;
+        final long startTime = System.currentTimeMillis();
+        sieveIt(n);
+        final long endTime = System.currentTimeMillis();
+        System.out.println(endTime-startTime);
+    }
+}

documents/Programmierparadigmen/scripts/java/SingleCorePrimeTest.java

@@ -0,0 +1,27 @@
+/* @author Axel Busch */
+public class SingleCorePrimeTest {
+
+    public static boolean isPrime(int n) {
+        if (n < 2) {
+            return false;
+        }
+
+        for (int i = 2; i <= Math.sqrt(n); ++i) {
+            if (n % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        int target = 10_000_000;
+        long start = System.currentTimeMillis();
+        for (int i = 2; i <= target; ++i) {
+            isPrime(i);
+        }
+        long end = System.currentTimeMillis();
+        System.out.println(end-start);
+    }
+    
+}