Better explanation of error.

It's buggy, at some point it gives a segmentation fault at around the
`for(auto i : primes)` part. I think I should add a pragma critical
there.

.gitignore

@@ -1,3 +1,6 @@
 # Ignore build files
 build/*
 !build/.keep
+
+# Ignore vim temporary files
+*.sw[a-z]

.gitlab-ci.yml

@@ -2,12 +2,19 @@ image: gcc
 
 build:
     stage: build
+    # Install dependencies
     before_script:
-        - apt update && apt -y install cmake
+        - apt update && apt -y install cmake libgmp-dev
+    # Build the project
     script:
         - cd build/
         - cmake -DCMAKE_BUILD_TYPE=Release ..
         - make
+    # Find the resulting binary
     artifacts:
         paths:
             - build/indivisible
+    # Cache .o files for faster compiling
+    cache:
+        paths:
+            - "*.o"

CHANGELOG

@@ -4,4 +4,8 @@ Change Log
 - v0.1: Initial release
 	- Basic prime calculation.
 	- Uses a growing vector of known primes and gets the modulus of the number divided by these primes.
-	- Uses type `long long` to hold prime numbers.
+	- Uses type `long long' to hold prime numbers.
+- v0.2: Multi-Precision
+	- Switch to C.
+	- Uses GNU Multiple Precision library (GMP) to hold prime numbers, allowing for 'infinite' size.
+	- Add `likely()' and `unlikely()' macros to optimize.

CMakeLists.txt

@@ -1,23 +1,39 @@
 cmake_minimum_required(VERSION 2.6)
 project(Indivisible)
 
+cmake_policy(SET CMP0012 OLD)
+
 set(TARGET_NAME indivisible)
 
 if(NOT CMAKE_BUILD_TYPE)
 	set(CMAKE_BUILD_TYPE Debug)
 endif()
 
-set(SRCS
-    src/Main.cpp)
+set(CMAKE_MODULE_PATH
+	${CMAKE_MODULE_PATH}
+	${CMAKE_SOURCE_DIR}/cmake/)
 
-set(CMAKE_CXX_FLAGS "-std=c++14 -fno-elide-constructors -pedantic-errors -Wall -Wextra -Werror -Wpedantic -Winit-self -Wmissing-declarations -Wuninitialized -Wfatal-errors")
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS} -O3")
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS} -g -O0")
-set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS} -g -O3")
-set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS} -Os")
+find_package(GMP REQUIRED)
+
+include_directories(
+	${GMP_INCLUDE_DIR})
+
+set(SRCS
+	src/main.c
+	src/list.c)
+
+# Define the C flags.
+set(CMAKE_C_FLAGS "-std=gnu99 -Wall -Wextra -Werror -Wfatal-errors -Wmissing-declarations -pedantic-errors")
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS} -g -O0")
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS} -O3")
+set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS} -g -O3")
+set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS} -Os")
 
 if(NOT CMAKE_BUILD_TYPE MATCHES Debug AND NOT CMAKE_BUILD_TYPE MATCHES RelWithDebInfo)
 	add_definitions(-DNDEBUG)
 endif()
 
 add_executable(${TARGET_NAME} ${SRCS})
+
+target_link_libraries(${TARGET_NAME}
+	${GMP_LIBRARY})

README.md

@@ -2,12 +2,15 @@ Indivisible
 ===========
 [![build status](https://gitlab.com/Deathsbreed/Indivisible/badges/master/build.svg)](https://gitlab.com/Deathsbreed/Indivisible/commits/master)
 
-Indivisible is an optimized prime number generator written in C++.
+Indivisible is an optimized prime number generator written in C.
 
 Building
 --------
-This project uses CMake to build.
+There are multiple dependencies to install before compiling the project:
+- CMake
+- GMP
 
+Once the dependencies are installed you can compile by running the following from the root directory of the project:
 ```bash
 $ cd build/
 $ cmake ..

cmake/FindGMP.cmake

@@ -0,0 +1,24 @@
+# SOURCE: http://stackoverflow.com/questions/29307862/error-linking-gmp-library
+set(GMP_PREFIX "" CACHE PATH "path ")
+
+find_path(GMP_INCLUDE_DIR gmp.h gmpxx.h
+	PATHS ${GMP_PREFIX}/include /usr/include /usr/local/include )
+
+find_library(GMP_LIBRARY NAMES gmp libgmp
+	PATHS ${GMP_PREFIX}/lib /usr/lib /usr/local/lib)
+
+
+if(GMP_INCLUDE_DIR AND GMP_LIBRARY)
+	get_filename_component(GMP_LIBRARY_DIR ${GMP_LIBRARY} PATH)
+	set(GMP_FOUND TRUE)
+endif()
+
+if(GMP_FOUND)
+	if(NOT GMP_FIND_QUIETLY)
+		MESSAGE(STATUS "Found GMP: ${GMP_LIBRARY}")
+	endif()
+else()
+	if(GMP_FIND_REQUIRED)
+		message(FATAL_ERROR "Could not find GMP")
+	endif()
+endif()

src/Main.cpp

@@ -1,38 +0,0 @@
-#include <iostream>
-#include <vector>
-#include <csignal>
-
-static bool run;
-
-void leave(int signum);
-
-int main(void) {
-	std::cout << "Indivisible v0.1\n";
-	run = true;
-
-	signal(SIGINT, leave);
-
-	std::vector<unsigned long long> primes;
-	primes.push_back(2);
-	unsigned long long num = 2;
-
-	while(run) {
-		bool isPrime = true;
-		for(auto i : primes) {
-			if(i > num / 2) break;
-			if(num % i == 0) isPrime = false;
-		}
-		if(isPrime) {
-			primes.push_back(num);
-			std::cout << num << std::endl;
-		}
-		++num;
-	}
-
-	return 0;
-}
-
-void leave(int signum) {
-	std::cout << "Exiting (" << signum << ")\n";
-	run = false;
-}

src/list.c

@@ -0,0 +1,46 @@
+#include "list.h"
+#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) {
+	l->list = malloc(sizeof(mpz_t) * BLOCK_SIZE);
+	if(!l->list) {
+		fprintf(stderr, "Failed to allocate memory to list!\n");
+		exit(1);
+	}
+	l->size = BLOCK_SIZE;
+	l->end = 0;
+}
+
+void deInitList(List *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(unlikely(l->end == l->size)) {
+		l->size += BLOCK_SIZE;
+		if(unlikely(l->size == 0)) {
+			fprintf(stderr, "`l->size' has overflowed!\n");
+			exit(1);
+		}
+		void *tmp = realloc(l->list, sizeof(mpz_t) * l->size);
+		if(unlikely(!tmp)) {
+			fprintf(stderr, "Failed to allocate more memory to list!\n");
+			exit(1);
+		}
+		l->list = (mpz_t*)tmp;
+	}
+	mpz_init(l->list[l->end]);
+	mpz_set(l->list[l->end++], n);
+}

src/list.h

@@ -0,0 +1,38 @@
+#pragma once
+#include <gmp.h>
+#include <stdbool.h>
+
+#include "types.h"
+
+/**
+ * @brief An infinitely expanding list type.
+ */
+typedef struct {
+	mpz_t *list; //!< The list of elements
+	ulli size; //!< How many elements are in the list
+	ulli end; //!< The last element of the list (in use)
+} List;
+
+/**
+ * @brief Initialize a List.
+ * @details Initialize the list and its variables, allocating memory
+ * to the pointer array inside. Returns true on success and false on
+ * failure.
+ * @param[in] l A pointer to a List type to be initialized.
+ */
+void initList(List *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);
+
+/**
+ * @brief Adds a new item to a List type.
+ * @details Add item `n' at the end of a List type.
+ * @param[out] l List to which the variable should be appended.
+ * @param[in] n variable to be appended to the list.
+ */
+void addToList(List *l, mpz_t n);

src/main.c

@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <gmp.h>
+
+#include "list.h"
+#include "types.h"
+#include "optimizers.h"
+
+static bool run;
+void leave();
+
+int main(void) {
+	printf("Indivisible v0.2\n");
+
+	// Quit on ^C by setting `run = false'
+	run = true;
+	signal(SIGINT, leave);
+
+	// Primes we've found
+	List primes;
+	initList(&primes);
+
+	// The number we're going to be testing for
+	mpz_t num;
+	mpz_init(num);
+
+	// Add 2, a known prime to this list
+	mpz_set_ui(num, 2);
+	addToList(&primes, num);
+	if(mpz_out_str(stdout, 10, num) == 0) {
+		fprintf(stderr, "Could not print to `stdout'!\n");
+		exit(1);
+	}
+	printf("\n");
+	mpz_add_ui(num, num, 1);
+
+	do {
+		// Loop through found primes
+		for(ulli i = 0; i < primes.size; ++i) {
+			// If `num' is divisible by a prime then go to the next number
+			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
+		addToList(&primes, num);
+		if(unlikely(mpz_out_str(stdout, 10, num) == 0)) {
+			fprintf(stderr, "Could not print to `stdout'!\n");
+			exit(1);
+		}
+		printf("\n");
+
+nextPrime:
+		// Add 2 (skip even numbers since they're all divisible by 2)
+		mpz_add_ui(num, num, 2);
+	} while(likely(run));
+
+	mpz_clear(num);
+	// Deinitialize the list
+	deInitList(&primes);
+	return 0;
+}
+
+void leave() {
+	printf("Exiting...\n");
+	run = false;
+}

src/optimizers.h

@@ -0,0 +1,3 @@
+#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;