Added a new algorithm that is really just the same algorithm all along.

Author: dsamarin

Makefile

@@ -1,4 +1,4 @@
-all: fib_naive fib_bottomup fib_matrix
+all: fib_naive fib_bottomup fib_matrix fib_vector fib_gmpbuiltin
 
 fib_naive: main.c fib_naive.c
 	gcc main.c fib_naive.c -lgmp -O3 -o fib_naive
@@ -9,7 +9,15 @@ fib_bottomup: main.c fib_bottomup.c
 fib_matrix: main.c fib_matrix.c
 	gcc main.c fib_matrix.c -lgmp -O3 -o fib_matrix
 
+fib_vector: main.c fib_vector.c
+	gcc main.c fib_vector.c -lgmp -O3 -o fib_vector
+
+fib_vector: main.c fib_gmpbuiltin.c
+	gcc main.c fib_gmpbuiltin.c -lgmp -O3 -o fib_gmpbuiltin
+
 clean:
 	rm -f fib_naive
 	rm -f fib_bottomup
 	rm -f fib_matrix
+	rm -f fib_vector
+	rm -f fib_gmpbuiltin

README.md

@@ -4,8 +4,8 @@ Fibonacci Algorithms
 This repository contains example programs of different algorithms used to calculate fibonacci numbers.
 
 
-Naive
------
+Naive (`fib_naive`)
+---------------------
 
 This algorithm is based directly on the mathematical definition. It has a running time of `Θ(ϕ^n)` where n is the term of the sequence. Exponential, not good.
 
@@ -15,8 +15,8 @@ This algorithm is based directly on the mathematical definition. It has a runnin
 		return fib (n - 1) + fib (n - 2);
 
 
-Bottom-up
----------
+Bottom-up (`fib_bottomup`)
+----------------------------
 
 This algorithm is called the bottom-up algorithm because it iterates from 0 to n adding as it goes along. It has a running time of `Θ(n)`. It's okay but we can do better.
 
@@ -33,14 +33,26 @@ This algorithm is called the bottom-up algorithm because it iterates from 0 to n
 		return b;
 
 
-Matrix multiplication
----------------------
+Matrix multiplication (`fib_matrix`)
+------------------------------------
 
-This uses exponentiation by squaring to compute the nth power of a 2x2 matrix. It has a running time of `Θ(log_2 n)`. It takes advantage of the theorem:
+This uses exponentiation by squaring to compute the nth power of a 2x2 matrix. It has a running time of `Θ(log n)`. It takes advantage of the theorem:
 
 	[[F_{n+1}, F_n], [F_n, F_{n-1}]] = [[1, 1], [1, 0]] ^ n;
 
 	function fib(n):
 		matrix = [[1, 1], [1, 0]];
 		matrix = matrix_pow (matrix, n); # Finding a power is O(log n) time with the exponentiation by squares method
 		return matrix[1, 2];
+
+
+Phi Z-component vector multiplication (`fib_vector`)
+----------------------------------------------------
+
+This is practically the same as above, but with fewer variables and simpler code. It has the same running time of `Θ(log n)`.
+
+
+GMP Built-in (`fib_gmpbuiltin`)
+-------------------------------
+
+The GMP library comes with its own routine for finding the nth fibonacci sequence. However it only accepts an `unsigned long int` argument instead of its `mpz_t` integer type.

fib_gmpbuiltin.c

@@ -0,0 +1,7 @@
+#include <gmp.h>
+
+void
+fib_compute (mpz_t result, mpz_t term)
+{
+	mpz_fib_ui (result, mpz_get_ui (term));
+}

fib_vector.c

@@ -1,44 +1,32 @@
 #include <gmp.h>
 
-void
-fib_matrix_mul (mpz_t a, mpz_t b, mpz_t c, mpz_t d, mpz_t e, mpz_t f, mpz_t g, mpz_t h)
+static inline void
+fib_component_mul (mpz_t a, mpz_t b, mpz_t c, mpz_t d)
 {
-	mpz_t r, s, t, u;
+	mpz_t r, s, bd;
 
 	mpz_init (r);
 	mpz_init (s);
-	mpz_init (t);
-	mpz_init (u);
+	mpz_init (bd);
 
-	mpz_mul (r, a, e);
-	mpz_mul (s, a, f);
-	mpz_mul (t, c, e);
-	mpz_mul (u, c, f);
+	mpz_mul (r, a, c);
+	mpz_mul (s, b, c);
+	mpz_mul (bd, b, d);
 
-	mpz_addmul (r, b, g);
-	mpz_addmul (s, b, h);
-	mpz_addmul (t, d, g);
-	mpz_addmul (u, d, h);
+	mpz_addmul (s, a, d);
+	mpz_add (r, r, bd);
+	mpz_add (s, s, bd);
 
 	mpz_set (a, r);
 	mpz_set (b, s);
-	mpz_set (c, t);
-	mpz_set (d, u);
 
 	mpz_clear (r);
 	mpz_clear (s);
-	mpz_clear (t);
-	mpz_clear (u);
-}
-
-void
-fib_matrix_square (mpz_t a, mpz_t b, mpz_t c, mpz_t d)
-{
-	fib_matrix_mul (a, b, c, d, a, b, c, d);
+	mpz_clear (bd);
 }
 
-void
-fib_matrix_pow (mpz_t a, mpz_t b, mpz_t c, mpz_t d, mpz_t term)
+static inline void
+fib_component_pow (mpz_t a, mpz_t b, mpz_t term)
 {
 	mpz_t half_term;
 
@@ -48,33 +36,27 @@ fib_matrix_pow (mpz_t a, mpz_t b, mpz_t c, mpz_t d, mpz_t term)
 
 	if (mpz_even_p (term)) {
 		mpz_tdiv_q_2exp (half_term, term, 1);
-		fib_matrix_pow (a, b, c, d, half_term);
-		fib_matrix_square (a, b, c, d);
+		fib_component_pow (a, b, half_term);
+		fib_component_mul (a, b, a, b);
 	} else {
-		mpz_t e, f, g, h;
-		mpz_init_set (e, a);
-		mpz_init_set (f, b);
-		mpz_init_set (g, c);
-		mpz_init_set (h, d);
+		mpz_t c, d;
+		mpz_init_set (c, a);
+		mpz_init_set (d, b);
 
 		mpz_sub_ui (half_term, term, 1);
 		mpz_tdiv_q_2exp (half_term, half_term, 1);
 
-		fib_matrix_pow (a, b, c, d, half_term);
-		fib_matrix_square (a, b, c, d);
-		fib_matrix_mul (a, b, c, d, e, f, g, h);
+		fib_component_pow (a, b, half_term);
+		fib_component_mul (a, b, a, b);
+		fib_component_mul (a, b, c, d);
 
-		mpz_clear (e);
-		mpz_clear (f);
-		mpz_clear (g);
-		mpz_clear (h);
+		mpz_clear (c);
+		mpz_clear (d);
 	}
 
 	mpz_clear (half_term);
 }
 
-void fib_vector_pow (
-
 void
 fib_compute (mpz_t result,
              mpz_t term)
@@ -84,31 +66,14 @@ fib_compute (mpz_t result,
 		return;
 	}
 
-	/* [F_n,0] = ([0,1]^n - [1,-1]^n) / [-1,2] */
-
-	mpz_t a, b, c, d, e, f;
+	mpz_t a, b;
 
 	mpz_init_set_si (a, 0);
 	mpz_init_set_si (b, 1);
 
-	mpz_init_set_si (c, 1);
-	mpz_init_set_si (d, -1);
-
-	mpz_init_set_si (e, -1);
-	mpz_init_set_si (f, 2);
-
-	fib_vector_pow (a, b, term);
-	fib_vector_pow (c, d, term);
-
-	fib_vector_sub (a, b, c, d);
-
-	fib_vector_div (a, b, e, f);
-	mpz_set (result, a);
+	fib_component_pow (a, b, term);
+	mpz_set (result, b);
 
 	mpz_clear (a);
 	mpz_clear (b);
-	mpz_clear (c);
-	mpz_clear (d);
-	mpz_clear (e);
-	mpz_clear (f);
 }