Added helpers for calculation primes.

primes.c

@@ -0,0 +1,108 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <math.h>
+
+/*
+ *  unmemoized version of isPrime
+ *  runs in O(sqrt(n))
+ *
+ */
+bool isPrime (int n) {
+    if (n == 0 || n == 1)
+        return false;
+
+    int sqrtn = (int) sqrt (n);
+    for (int i = 2; i <= sqrtn; i++) {
+        if (n % i == 0)
+            return false;
+    }
+    return true;
+}
+
+/*
+ *  memoized version of isPrime
+ *  primes: list of primes < n
+ *  runs in O(sqrt(n)/ln(n))
+ *
+ */
+bool isPrimeMem (int n, int* primes) {
+    if (n == 0 || n == 1)
+        return false;
+    if (n == 2 || n == 3)
+        return true;
+
+    int sqrtn = (int) sqrt (n);
+    int i = 0;
+    while (primes[i] <= sqrtn) {
+        if (n % primes[i++] == 0)
+            return false;
+    }
+    return true;
+}
+
+/*
+ *  calculates primes <= n using dynamic programming
+ *
+ *  n: non-negative int
+ *  primes_ptr: pointer to array of primes <= n
+ *  primesTable_ptr: pointer to array of size n+1
+ *      where the 0-based ith element is true if i is prime
+ *  returns: number of primes in *primes_ptr
+ *
+ *  N.B. numOfPrimesUpper is an upper-bound of 
+ *      the prime-counting function, given by 
+ *      n/ln(n) * (1 + 3/2 * 1/ln(n))
+ *
+ *  runs in O(n * sqrt(n)/ln(n)) (not a tight bound)
+ *
+ */
+
+int listOfPrimes (int n, int** primes_ptr, bool** primesTable_ptr) {
+    *primesTable_ptr = calloc (n + 1, sizeof (bool));
+
+    if (n == 0 || n == 1) {
+        *primes_ptr = malloc (0);
+        return 0;
+    }
+
+    int numOfPrimesUpper = (int) (n/log(n) * 
+                    (1 + 3/2 * 1/log(n)));
+    *primes_ptr = malloc (sizeof (int) * numOfPrimesUpper);
+    int numOfPrimes = 0;
+    for (int i = 0; i <= n; i++) {
+        if (isPrimeMem (i, *primes_ptr)) {
+            (*primes_ptr)[numOfPrimes++] = i;
+            (*primesTable_ptr)[i] = true;
+        }
+    }
+    if (numOfPrimes < numOfPrimesUpper)
+        *primes_ptr = realloc (*primes_ptr, 
+                        sizeof (int) * numOfPrimes);
+    
+    return numOfPrimes;
+}
+
+/*
+ *  calculates primes <= n are prime using the sieve of Eratosthenes
+ *
+ *  runs in O(n ln(ln(n))) apparently
+ *
+ */
+void sieveOfEratosthenes (int n, bool** primesTable_ptr) {
+    *primesTable_ptr = malloc (sizeof (bool) * (n + 1));
+    for (int i = 0; i <= n; i++)
+        (*primesTable_ptr)[i] = true;
+
+    (*primesTable_ptr)[0] = false;
+    (*primesTable_ptr)[1] = false;
+
+    int sqrtn = (int) sqrt (n);
+    for (int i = 0; i <= sqrtn; i++) {
+        if ((*primesTable_ptr)[i] == true) {
+            for (int j = i*2; j <= n; j += i) {
+                (*primesTable_ptr)[j] = false;
+            }
+        }
+    }
+}

primes.h

@@ -0,0 +1,4 @@
+bool isPrime (int n);
+bool isPrimeMem (int n, int* primes);
+int listOfPrimes (int n, int** primes_ptr, bool** primesTable_ptr);
+void sieveOfEratosthenes (int n, bool** primesTable_ptr);