New goal for v0.4

Add restrict for better pointer optimizations. This is not being applied
to `addToList()' because that function we want to thread later on.

.gitlab-ci.yml

@@ -17,4 +17,4 @@ build:
     # Cache .o files for faster compiling
     cache:
         paths:
-            - "*.o"
+            - "build/CMakeFiles/indivisible.dir/src/*.o"

CHANGELOG

@@ -9,3 +9,13 @@ Change Log
 	- Switch to C.
 	- Uses GNU Multiple Precision library (GMP) to hold prime numbers, allowing for 'infinite' size.
 	- Add `likely()' and `unlikely()' macros to optimize.
+- v0.2.1: Memory Leak Fixes
+	- Fixed a major memory leak at the end of the program.
+	- Added more optimizers.
+- v0.3: Optimizations
+	- Algorithm skips half the known primes.
+	- Removed `likely()' and `unlikely()' macros due to lack of information.
+	- Improved performance.
+- v0.4: Fixed Algorithm
+	- Fixed algorithm to actually calculate primes.
+	- Added extra C99 optimizations.

src/list.c

@@ -2,15 +2,13 @@
 #include <stdlib.h>
 #include <stdio.h>
 
-#include "optimizers.h"
-
 /**
  * This is the number of elements by which the list expands.
  * WARNING: Always use doubles for this number (2^X)
  */
 #define BLOCK_SIZE 1024
 
-void initList(List *l) {
+void initList(List *restrict l) {
 	l->list = malloc(sizeof(mpz_t) * BLOCK_SIZE);
 	if(!l->list) {
 		fprintf(stderr, "Failed to allocate memory to list!\n");
@@ -20,16 +18,18 @@ void initList(List *l) {
 	l->end = 0;
 }
 
-void deInitList(List *l) {
+void deInitList(List *restrict l) {
+	for(ulli i = 0; i < l->size; ++i) {
+		mpz_clear(l->list[i]);
+	}
 	free(l->list);
 }
 
 void addToList(List *l, mpz_t n) {
 	if(l->end == l->size) {
 		l->size += BLOCK_SIZE;
-		if(unlikely(l->size == 0)) {
-			fprintf(stderr,
-					"size has reached limit of `long long int' type!\n");
+		if(l->size == 0) {
+			fprintf(stderr, "`l->size' has overflowed!\n");
 			exit(1);
 		}
 		void *tmp = realloc(l->list, sizeof(mpz_t) * l->size);

src/list.h

@@ -2,13 +2,15 @@
 #include <gmp.h>
 #include <stdbool.h>
 
+#include "types.h"
+
 /**
  * @brief An infinitely expanding list type.
  */
 typedef struct {
 	mpz_t *list; //!< The list of elements
-	unsigned long long int size; //!< How many elements are in the list
-	unsigned long long int end; //!< The last element of the list (in use)
+	ulli size; //!< How many elements are in the list
+	ulli end; //!< The last element of the list (in use)
 } List;
 
 /**
@@ -18,14 +20,14 @@ typedef struct {
  * failure.
  * @param[in] l A pointer to a List type to be initialized.
  */
-void initList(List *l);
+void initList(List *restrict l);
 
 /**
  * @brief Deinitialize a List.
  * @details Release all memory that has been allocated to the list.
  * @param[in] l A pointer to a List type to be deinitialized.
  */
-void deInitList(List *l);
+void deInitList(List *restrict l);
 
 /**
  * @brief Adds a new item to a List type.

src/main.c

@@ -5,12 +5,13 @@
 #include <gmp.h>
 
 #include "list.h"
+#include "types.h"
 
 static bool run;
 void leave();
 
 int main(void) {
-	printf("Indivisible v0.2\n");
+	puts("Indivisible v0.4\n");
 
 	// Quit on ^C by setting `run = false'
 	run = true;
@@ -34,11 +35,19 @@ int main(void) {
 	printf("\n");
 	mpz_add_ui(num, num, 1);
 
+	// Variable for half `num'
+	mpz_t halfNum;
+	mpz_init(halfNum);
+
 	do {
+		// Calculate half of `num'
+		mpz_fdiv_q_ui(halfNum, num, 2);
 		// Loop through found primes
-		for(unsigned long long int i = 0; i < primes.size; ++i) {
+		for(ulli i = 0; i < primes.end; ++i) {
+			if(mpz_cmp(primes.list[i], halfNum) >= 0) break;
 			// If `num' is divisible by a prime then go to the next number
-			if(mpz_divisible_p(num, primes.list[i]) != 0) goto nextPrime;
+			if(mpz_divisible_p(num, primes.list[i]) != 0)
+				goto nextPrime;
 		}
 
 		// `num' is a prime so we add it to the list and print it
@@ -54,12 +63,15 @@ nextPrime:
 		mpz_add_ui(num, num, 2);
 	} while(run);
 
+	// Clear GMP variables
+	mpz_clear(halfNum);
+	mpz_clear(num);
 	// Deinitialize the list
 	deInitList(&primes);
 	return 0;
 }
 
 void leave() {
-	printf("Exiting...\n");
+	puts("Exiting...\n");
 	run = false;
 }

src/optimizers.h

@@ -1,3 +0,0 @@
-#pragma once
-#define likely(x)    __builtin_expect(!!(x), 1)
-#define unlikely(x)  __builtin_expect(!!(x), 0)

src/types.h

@@ -0,0 +1,2 @@
+#pragma once
+typedef unsigned long long int ulli;