congruence_solver 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b8cdf5634b888651240db1d379330c26e0915815
-  data.tar.gz: cb6e241768d62d727196d40600aed3da6c8d8cbd
+  metadata.gz: eb92ff33b8d060a03e8a3d7012e4245a39df5583
+  data.tar.gz: b07e0989fc34a3c4126e4dbfff4100b2dc8d9f5f
 SHA512:
-  metadata.gz: c656aba94e133852ff5a6cb03cb4e4d35e7df80bc60205254caf6ffb1b8bb486121c939a2f8c63dce9dc3881b7ad48840d7a63619b1839faa18acca2148a72bb
-  data.tar.gz: 84930366fe58c6f75167c673b180b5d1dcc89e38540160f0281b1c10ba100eb7603d23f63ea6346d8ea7117030ae2274d27f82433cc9c5542aa9496d3ee4f146
+  metadata.gz: f904157465b3870e19e18b7e5d567a99cd3012a52f9c892eb5ebeaf51eaa08e8cabee1979bb386b1c52be0640b9eac60803f6f562333e4c8232f24b01a9a2d98
+  data.tar.gz: 1c912d27c225d6b9d6cd06d5b0509a406ae336714dbb1f63c3af778f7dc62358afdfbd319891e1745bf455ed66f1f87d795d5d816b5ac3902dd080edf9c8982a

data/congruence_solver.gemspec

@@ -17,8 +17,13 @@ Gem::Specification.new do |spec|
 
   spec.files         = `git ls-files`.split("\n")
   spec.files        += `git submodule --quiet foreach pwd`.split("\n").map do |abs_dir|
-                          rel_dir = abs_dir.gsub(Dir::pwd, "")
-                          Dir::entries(rel_dir).select {|f| File::file? f}
+                          abs_dir = abs_dir.gsub(/^c:/, "C:")
+                          root = Dir::pwd
+                          dir_in_proj = abs_dir.gsub(/^#{root}\/?/, "")
+                          Dir::chdir(abs_dir)
+                          files = `git ls-files`.split("\n")
+                          Dir::chdir(root)
+                          files.map {|fname| "#{dir_in_proj}/#{fname}"}
                         end.flatten
   spec.bindir        = "bin"
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }

data/ext/congruence_solver/.gitignore

@@ -0,0 +1,2 @@
+todo
+*.exe

data/ext/congruence_solver/Makefile

@@ -0,0 +1,18 @@
+
+congruences_test: congruences.c test/congruences_test.c test/congruences_test.h arith_utils.c prime_gen.c
+	gcc -g prime_gen.c arith_utils.c congruences.c test/congruences_test.c -o congruences_test
+
+arith_utils_test: arith_utils.c test/arith_utils_test.c test/arith_utils_test.h prime_gen.c
+	gcc -g prime_gen.c arith_utils.c test/arith_utils_test.c -o arith_utils_test
+
+prime_gen_test: prime_gen.c test/prime_gen_test.c test/prime_gen_test.h
+	gcc -g prime_gen.c test/prime_gen_test.c -o prime_gen_test
+
+test: prime_gen_test arith_utils_test congruences_test
+	./prime_gen_test
+	./arith_utils_test
+	./congruences_test
+
+clean:
+	rm -f prime_gen_test.exe arith_utils_test.exe congruences_test.exe
+	

data/ext/congruence_solver/arith_utils.c

@@ -0,0 +1,139 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "prime_gen.h"
+#include "arith_utils.h"
+
+
+int mod_sum(int x, int y, int mod){
+	x %= mod;
+	y %= mod;
+
+	if(y >= mod - x){
+		return y - (mod - x);
+	}
+
+	else{
+		return y + x;
+	}
+}
+
+
+int mod_inv(int n, int mod){
+	int y, a;
+
+	if(n!=0){
+
+		while(n<0){
+			n+=mod;
+		}
+
+		for(y = 1; y < mod; y++){
+			a = mod_product(y, n, mod);
+
+			if(a == 1){
+				return y;
+			}
+		}
+	}
+
+	return 0;
+}
+
+
+int coprime(int n1, int n2){
+	//naive algorithm but efficient when n1 has already been factorized
+	int * n1Factors = prime_factors(n1);
+	int numOfFactors = *n1Factors;
+	int * factors = n1Factors+1;
+	int shareFactor = 0;
+	int i;
+
+	for(i=0; i<numOfFactors; i++){
+		if(n2 % factors[i] == 0){
+			shareFactor = 1;
+			break;
+		}
+	}
+
+	free(n1Factors);
+
+	return !shareFactor;
+}
+
+
+int mod_product(int num1, int num2, int mod){
+	int prod = 0;
+	int i;
+
+	for(i = 0; i < num1; i++){
+		prod = mod_sum(prod, num2, mod);
+	}
+
+	return prod;
+}
+
+
+int mod_power(int n, int power, int mod){
+	int product = n;
+	int i;
+
+	for(i = 1; i < power; i++){
+		product = mod_product(product, n, mod);
+	}
+
+	return product;
+}
+
+
+int totient(int n){
+	int * divisorList = prime_factors(n);
+	int listLength = divisorList[0];
+	int * divisors = divisorList+1;
+	int i;
+
+	for(i = 0; i < listLength; i++){
+		n *= (divisors[i] - 1);
+		n /= divisors[i];
+	}
+
+	free(divisorList);
+
+	return n;
+}
+
+
+
+
+int mod_eval_polynomial(int degree, int coeffs[], int mod, int x){
+	int sum = coeffs[0];
+	int i;
+
+	for(i = 1; i <= degree; i++){
+		sum += mod_power(x, i, mod)*coeffs[i];
+		sum %= mod;
+	}
+
+	return sum;
+}
+
+
+long  eval_polynomial(int degree, int coeffs[], int x){
+	long int sum = coeffs[0];
+ 	long int powx;
+	int i;
+
+	for(i = 1, powx = x; i <= degree; i++, powx*=x){
+		sum += powx*coeffs[i];
+	}
+
+	return sum;
+}
+
+
+
+
+/*
+int * linear_diophantine_solution(int order, int coeffs[], int scal){
+
+*=}
+*/

data/ext/congruence_solver/arith_utils.h

@@ -0,0 +1,10 @@
+#ifndef H_ARITH_UTILS
+#define H_ARITH_UTILS
+int mod_inv(int n, int mod);
+int mod_product(int n1, int n2, int mod);
+int mod_power(int n, int power, int mod);
+int mod_eval_polynomial(int degree, int coeffs[], int mod, int x);
+long eval_polynomial(int degree, int coeffs[], int x);
+int coprime(int n1, int n2);
+int totient(int n);
+#endif

data/ext/congruence_solver/congruence_solver.c

@@ -0,0 +1,85 @@
+#include <ruby.h>
+#include "congruences.h"
+#include "arith_utils.h"
+#include "prime_gen.h"
+
+
+VALUE CongruenceSolver = Qnil;
+
+void Init_congruence_solver();
+VALUE method_congruence_solver_lift(VALUE self, VALUE funcCoeffs, VALUE mod);
+VALUE method_congruence_solver_brute_force(VALUE self, VALUE funcoeffs, VALUE mod);
+//VALUE method_congruence_solver_solve_system_of_congruences(VALUE self, VALUE funcDegreeAry, VALUE aryOfFuncCoeffArys, VALUE modAry);
+
+
+void Init_congruence_solver(){
+	CongruenceSolver = rb_define_module("CongruenceSolver");
+	
+	rb_define_singleton_method(CongruenceSolver, "lift",
+								method_congruence_solver_lift, 2);
+
+	rb_define_singleton_method(CongruenceSolver, "brute_force", 
+								method_congruence_solver_brute_force, 2);
+
+	/*rb_define_singleton_method(CongruenceSolver, "solve_system_of_congruences", 
+								method_congruence_solver_solve_system_of_congruence, 3);
+	*/
+}
+
+
+VALUE method_congruence_solver_brute_force(VALUE self, VALUE funcCoeffs, VALUE mod){
+	int i;
+	int * intSolutions;
+	VALUE rbSolutions;
+	int intMod = NUM2INT(mod);
+
+	int intFuncDegree = RARRAY_LEN(funcCoeffs)-1;
+	int * intFuncCoeffs = calloc(intFuncDegree+1, sizeof(int));
+
+	for(i = 0; i <= intFuncDegree; i++){
+		intFuncCoeffs[i] = NUM2INT(rb_ary_entry(funcCoeffs, i));
+	}
+
+	intSolutions = brute_force_congruence(intFuncDegree, intFuncCoeffs, intMod);
+	rbSolutions = rb_ary_new2(intSolutions[0]);
+
+	for(i=0; i<intSolutions[0]; i++){
+		rb_ary_store(rbSolutions, i, INT2NUM(intSolutions[i+1]));
+	}
+
+
+	free(intFuncCoeffs);
+	free(intSolutions);
+
+	return rbSolutions;
+}
+ 
+
+VALUE method_congruence_solver_lift(VALUE self, VALUE funcCoeffs, VALUE mod){
+	int i;
+	int * intSolutions;
+	VALUE rbSolutions;
+	int intMod = NUM2INT(mod);
+
+	int intFuncDegree = RARRAY_LEN(funcCoeffs)-1;
+	int * intFuncCoeffs = calloc(intFuncDegree+1, sizeof(int));
+
+	for(i=0; i<=intFuncDegree; i++){
+		intFuncCoeffs[i] = NUM2INT(rb_ary_entry(funcCoeffs, i));
+	}
+
+
+	intSolutions = solve_congruence(intFuncDegree, intFuncCoeffs, intMod);
+	rbSolutions = rb_ary_new2(intSolutions[0]);
+
+	for(i=0; i<intSolutions[0]; i++){
+		rb_ary_store(rbSolutions, i, INT2NUM(intSolutions[i+1]));
+	}
+
+
+	free(intFuncCoeffs);
+	free(intSolutions);
+
+	return rbSolutions;
+}
+

data/ext/congruence_solver/congruences.c

@@ -0,0 +1,199 @@
+#include "arith_utils.h"
+#include "prime_gen.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+static int * solve_prime_power_congruence(int degree, int coeffs[], int prime, int power);
+static int * solve_system_of_order_1_congruence_sets(int numOfSets, int * lengthsOfSets, int ** sets, int mods[]);
+
+int chinese_remainder_solution(int numberOfEquations, int scals[], int mods[]){
+	int i;
+	int x = 0;
+	int m = mods[0];
+	int modCoeff;
+
+	for(i=1; i<numberOfEquations; i++){
+		m *= mods[i];
+	}
+
+	for(i=0; i<numberOfEquations; i++){
+		modCoeff = m/mods[i];
+		x += modCoeff*mod_inv(modCoeff, mods[i])*scals[i];
+	}
+
+	return x % m;
+}
+
+
+int * brute_force_congruence(int degree, int coeffs[], int primeMod){
+	//assumes a prime modulus. split congruences of composite modulus into systems of congrueneces
+	//of prime modulus and/or apply the lifting theorem to make use of this function
+	//solve a0x^n + a1x^n-1... = 0 (mod mod) where n is the order a0, a1, ... are coeffieicients
+	int * solutionList = calloc(degree+1, sizeof(int));
+	int * solutions = solutionList+1;
+	int numberOfSolutions = 0;
+	int x;
+
+	for(x = 0; x < primeMod && numberOfSolutions <= degree; x++){
+		if(mod_eval_polynomial(degree, coeffs, primeMod, x) == 0){
+			solutions[numberOfSolutions++] = x;
+		}
+	}
+
+	*solutionList = numberOfSolutions;
+
+	return solutionList;
+}
+
+
+static int * solve_prime_power_congruence(int funcDegree, int funcCoeffs[], int prime, int power){
+
+	int * baseSolutionList;
+	int numOfBaseSolutions;
+	int * baseSolutions;
+
+	int * liftedSolutions;
+	int numOfLiftedSolutions;
+
+	int derivDegree;
+	int * derivCoeffs;
+	int deriv;
+	long int divFunc;
+
+	int j, t;
+	int currentMod;
+
+	if(power == 1){
+		return brute_force_congruence(funcDegree, funcCoeffs, prime);
+	}
+
+	baseSolutionList = solve_prime_power_congruence(funcDegree, funcCoeffs, prime, power-1);
+	numOfBaseSolutions = *baseSolutionList;
+	baseSolutions = baseSolutionList+1;
+
+	liftedSolutions = calloc(prime*numOfBaseSolutions+1, sizeof(int));
+	numOfLiftedSolutions = 0;
+
+	derivDegree = funcDegree-1;
+	derivCoeffs = calloc(derivDegree+1, sizeof(int));
+
+	currentMod = prime;
+	for(j = 1; j < power; j++){
+		currentMod *= prime;
+	}
+
+	for(j = 0; j <= derivDegree; j++){ 
+		derivCoeffs[j] = funcCoeffs[j+1]*(j+1);
+	}
+
+
+	for(j = 0; j < numOfBaseSolutions; j++){
+		deriv = mod_eval_polynomial(derivDegree, derivCoeffs, prime, baseSolutions[j]);
+		divFunc = (eval_polynomial(funcDegree, funcCoeffs, baseSolutions[j]) / (currentMod/prime)) % prime;
+
+		if(deriv % prime != 0){
+			t = (-divFunc*mod_inv(deriv, prime) % prime) + prime;
+			liftedSolutions[++numOfLiftedSolutions] = baseSolutions[j] + t*prime;
+		}
+
+		else if(divFunc % prime == 0){
+			for(t = 1; t <= prime; t++){
+				liftedSolutions[++numOfLiftedSolutions] = baseSolutions[j] + t*(currentMod/prime);
+			}
+		}
+	}
+
+
+	*liftedSolutions = numOfLiftedSolutions;
+
+	free(derivCoeffs);
+	free(baseSolutionList);
+
+	return liftedSolutions;
+}
+
+
+static int * solve_system_of_order_1_congruence_sets(int numOfSets, int * setLengths, int * * sets, int * mods){
+	//allocate perumtation array
+	int * divAry = calloc(numOfSets, sizeof(int));
+	int * scalAry = calloc(numOfSets, sizeof(int));
+	int i, j;
+	int numOfSolutions;
+	int * solutionAry;
+	int * dest;
+	int idx;
+
+	for(i = 0, numOfSolutions = 1; i < numOfSets; i++){
+		divAry[i] = numOfSolutions;
+		numOfSolutions *= setLengths[i];
+	}
+
+	solutionAry = calloc(numOfSolutions+1, sizeof(int));
+	solutionAry[0] = numOfSolutions;
+	dest = solutionAry+1;
+
+	for(i = 0; i < numOfSolutions; i++){
+		for(j = 0; j < numOfSets; j++){
+			idx = (i / divAry[j]) % setLengths[j];
+			scalAry[j] = sets[j][idx];
+		}
+
+		*(dest++) = chinese_remainder_solution(numOfSets, scalAry, mods);
+	}
+
+	return solutionAry;
+}
+
+int * solve_congruence(int funcDegree, int funcCoeffs[], int mod){
+	int * solutionList;
+
+	int * modFactorList = prime_factors(mod);
+	int numOfModFactors = *modFactorList;
+	int * modFactors = modFactorList+1;
+
+	int * * primePowerSolutions = calloc(numOfModFactors, sizeof(int *));
+	int * primePowers = calloc(numOfModFactors, sizeof(int));
+	int * primePowerSolutionLengths = calloc(numOfModFactors, sizeof(int *));
+
+	int power;
+	int i;
+
+	for(i = 0; i < numOfModFactors; i++){
+		primePowers[i] = modFactors[i]; 
+		power = 1;
+		
+		while(mod % (primePowers[i]*modFactors[i]) == 0){
+			primePowers[i] *= modFactors[i];
+			power++;
+		}
+
+		primePowerSolutions[i] = solve_prime_power_congruence(funcDegree, funcCoeffs, modFactors[i], power);
+		primePowerSolutionLengths[i] = *(primePowerSolutions[i]++);
+	}
+
+
+	solutionList = solve_system_of_order_1_congruence_sets(numOfModFactors, primePowerSolutionLengths, primePowerSolutions, primePowers);
+
+	for(i = 0; i < numOfModFactors; i++){
+		free(primePowerSolutions[i] - 1);
+	}
+	free(primePowerSolutionLengths);
+	free(primePowerSolutions);
+	free(primePowers);
+	free(modFactorList);
+
+	return solutionList;
+}
+
+/*
+int * solve_system_of_congruences(int numOfFuncs, int * funcDegrees, int ** funcCoeffs, int * mods){
+	int i;
+	int * * funcSolutionSets = calloc(numOfFuncs, sizeof(int *));
+
+	for(i=0; i<numOfFuncs; i++){
+		funcSolutionSets[i] = solve_congruence(funcDegrees[i], funcCoeffs[i], mods[i]);
+	}
+
+	return solve_system_of_congruence_sets(numOfFuncs, funcSolutionSets, mods);
+}	
+*/

data/ext/congruence_solver/congruences.h

@@ -0,0 +1,7 @@
+#ifndef H_CONGRUENCES
+#define H_CONGRUENCES
+int chinese_remainder_solution(int numOfEquations, int scals[], int mods[]);
+int * solve_congruence(int funcDegree, int funcCoeffs[], int mod);
+int * brute_force_congruence(int degree, int coeffs[], int primeMod);
+//int * solve_system_of_congruences(int numOfFuncs, int * funcDegrees, int ** funcCoeffs, int * mods);
+#endif

data/ext/congruence_solver/extconf.rb

@@ -1,4 +1,29 @@
 require "mkmf"
 
+EXT_H = %w[
+	arith_utils.h
+	congruences.h
+	prime_gen.h
+]
 
-create_makefile "congruence_solver"
+EXT_C = %w[
+	arith_utils.c
+	congruence_solver.c
+	congruences.c
+	prime_gen.c
+]
+
+
+EXT_H.each do |fname| 
+	unless File::exist? fname
+		raise "Ext header #{fname} does not exist in #{Dir::pwd}"
+	end
+end
+
+EXT_C.each do |fname|
+	unless File::exist? fname
+		raise "Ext file #{fname} does not exist in #{Dir::pwd}" 
+	end
+end
+
+create_makefile "congruence_solver/congruence_solver"

data/ext/congruence_solver/prime_gen.c

@@ -0,0 +1,146 @@
+#include "prime_gen.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+
+#define FIRST_PRIME 2
+
+static void expand_prime_list_to_length(int length);
+static void expand_prime_list_past(int max);
+static int any_divisors(int * div_list, int length, int num);
+static int least_divisor(int n);
+
+static int * PRIME_LIST = NULL;
+static int PRIME_LIST_LENGTH = 0;
+static int PRIME_LIST_MAX_LENGTH = 0;
+static int NEXT_INTEGER = FIRST_PRIME;
+
+
+int * primes(int length){
+	int * rtrn_list = calloc(length, sizeof(int));
+
+	expand_prime_list_to_length(length);
+
+	if(rtrn_list != NULL){
+		memcpy(rtrn_list, PRIME_LIST, length*sizeof(int));
+	}
+
+	return rtrn_list;
+}
+
+
+int * primes_upto(int max){
+	int * rtrn_list;
+	int i;
+
+	expand_prime_list_past(max);
+
+	for(i = PRIME_LIST_LENGTH; i > 0; i--){
+		if(PRIME_LIST[i-1] <= max){
+			rtrn_list = calloc(i+1, sizeof(int));
+			rtrn_list[0] = i;
+			memcpy(rtrn_list+1, PRIME_LIST, i*sizeof(int));
+			return rtrn_list;
+		}
+	}
+
+	return NULL;
+}
+
+
+int * prime_factors(int n){
+	int * rtrn_list = malloc(sizeof(int));
+	int rtrn_list_length = 0;
+	int least_div;
+
+	while(n != 1){
+		least_div = least_divisor(n);
+		rtrn_list = realloc(rtrn_list, (rtrn_list_length+2)*sizeof(int));
+		rtrn_list[++rtrn_list_length] = least_div;
+
+		if(least_div == n){
+			break;
+		}
+
+		while(n % least_div == 0){
+			n /= least_div;
+		}
+	}
+
+	rtrn_list[0] = rtrn_list_length;
+
+	return rtrn_list;
+}
+
+
+static int least_divisor(int n){
+	//Calculate maximum for least divisor (sqrt)
+	int least_div_max = sqrt(n) + 1;
+	int i;
+	//Expand prime list up to the least divisor
+	expand_prime_list_past(least_div_max);
+
+
+	for(i = 0; PRIME_LIST[i] < least_div_max; i++){
+		if(n % PRIME_LIST[i] == 0){
+			return PRIME_LIST[i];
+		}
+	}
+
+	return n;
+}
+
+
+static void expand_prime_list_to_length(int length){
+
+	if(PRIME_LIST_MAX_LENGTH < length){
+		PRIME_LIST_MAX_LENGTH = 2*length;
+		PRIME_LIST = realloc(PRIME_LIST, PRIME_LIST_MAX_LENGTH*sizeof(int));
+	}
+
+	while(PRIME_LIST_LENGTH < length){
+		if( !any_divisors(PRIME_LIST, PRIME_LIST_LENGTH, NEXT_INTEGER) ){
+			PRIME_LIST[PRIME_LIST_LENGTH++] = NEXT_INTEGER;
+		}
+
+		NEXT_INTEGER++;
+	}
+
+}
+
+
+static void expand_prime_list_past(int max){
+	if(PRIME_LIST == NULL){
+		//TODO: find better heuristic limit on memory necessary to allocate
+		PRIME_LIST_MAX_LENGTH = (max/2) + 1;
+		PRIME_LIST = calloc(PRIME_LIST_MAX_LENGTH, sizeof(int));
+		PRIME_LIST[0] = NEXT_INTEGER++;
+		PRIME_LIST_LENGTH = 1;
+	}
+	
+	while(PRIME_LIST[PRIME_LIST_LENGTH-1] <= max){
+		while(any_divisors(PRIME_LIST, PRIME_LIST_LENGTH, NEXT_INTEGER) ){
+			NEXT_INTEGER++;
+		}
+
+		if( PRIME_LIST_MAX_LENGTH <= PRIME_LIST_LENGTH){
+			PRIME_LIST_MAX_LENGTH *= 2;
+			PRIME_LIST = realloc(PRIME_LIST, PRIME_LIST_MAX_LENGTH*sizeof(int));
+		}
+
+		PRIME_LIST[PRIME_LIST_LENGTH++] = NEXT_INTEGER;
+	}
+}
+
+
+static int any_divisors(int * div_list, int length, int num){
+	int i;
+	for(i = 0; i < length; i++){
+		if(num % div_list[i] == 0){
+			return 1;
+		}
+	}
+
+	return 0;
+}

data/ext/congruence_solver/prime_gen.h

@@ -0,0 +1,10 @@
+#ifndef H_PRIME_GEN
+#define H_PRIME_GEN
+int * primes(int n);
+
+//Generation of primes is currently time-prohibitive when generating up to large maximums. 
+//This should be acceptable for prime factorization because although naive the algorithm is 
+//somewhat optimized to detect relatively large prime factors.
+int * primes_upto(int max);
+int * prime_factors(int n);
+#endif

data/ext/congruence_solver/test/arith_utils_test.c

@@ -0,0 +1,106 @@
+#include <stdio.h>
+#include "../arith_utils.h"
+#include "arith_utils_test.h"
+
+int main(){
+	int failures = 0;
+	int i;
+
+	for(i = 0; i < NUM_OF_MOD_INV_TESTS; i++){
+		failures += mod_inv_test(MOD_INV_NUMS[i], MOD_INV_MODS[i], MOD_INV_INVS[i]);
+	}
+	
+	for(i = 0; i < NUM_OF_MOD_PRODUCT_TESTS; i++){
+		failures += mod_product_test(MOD_PRODUCT_NUM_PAIRS[i], MOD_PRODUCT_MODS[i], MOD_PRODUCT_PRODUCTS[i]);
+	}
+
+	for(i = 0; i < NUM_OF_MOD_POWER_TESTS; i++){
+		failures += mod_power_test(MOD_POWER_NUMS[i], MOD_POWER_MODS[i], MOD_POWER_POWERS[i], MOD_POWER_EVALS[i]);
+	}
+	
+	for(i = 0; i < NUM_OF_COPRIME_TESTS; i++){
+		failures += coprime_test(COPRIME_NUM_PAIRS[i], COPRIME_EVALS[i]);
+	}
+
+	for(i = 0; i < NUM_OF_TOTIENT_TESTS; i++){
+		failures += totient_test(TOTIENT_NUMS[i], TOTIENT_EVALS[i]);
+	}
+
+	printf("%d functions failing in arith_utils.c\n\n", failures);
+	return failures;
+}
+
+
+int totient_test(int num, int tot){ 
+	int eval_totient = totient(num);
+
+	if(tot != eval_totient){
+		printf("Totient of %d incorrectly evaluated: %d given instead of %d.\n", 
+				num, eval_totient, tot);
+		return 1;
+	}
+
+	else{
+		return 0;
+	}
+}
+
+
+int coprime_test(int * pair, int isCoprime){
+	int evalCoprime = coprime(pair[0], pair[1]);
+
+	if(isCoprime && !evalCoprime){
+		printf("%d and %d incorrectly evaluated as not coprime.\n", 
+				pair[0], pair[1]);
+		return 1;
+	}
+
+	else if(!isCoprime && evalCoprime){
+		printf("%d and %d incorrectly evaluated as coprime.\n",
+				pair[0], pair[1]);
+		return 1;
+	}
+
+	else{
+		return 0;
+	}
+}
+
+
+int mod_power_test(int num, int mod, int pwr, int mdpwr){
+	int mdpwrEval = mod_power(num, pwr, mod);
+
+	if(mdpwrEval != mdpwr){
+		printf("Incorrect evaluation of %d^%d mod %d: %d instead of %d.\n", 
+				num, pwr, mod, mdpwrEval, mdpwr);
+		return 1;
+	}
+
+	return 0;
+}
+
+
+int mod_product_test(int * pair, int mod, int product){
+	int prod = mod_product(pair[0], pair[1], mod);
+
+	if(prod != product){
+		printf("Incorrect evaluation of %d*%d mod %d: %d instead of %d.\n", 
+				pair[0], pair[1], mod, prod, product);
+		return 1;
+	}
+
+	return 0;
+}
+
+
+int mod_inv_test(int num, int mod, int inv){
+	int invEval = mod_inv(num, mod);
+	
+	if(inv != invEval){
+		printf("Incorrect evaluation of %d^-1 mod %d: %d instead of %d.\n", num, mod, invEval, inv);
+		return 1;
+	}
+
+	return 0;
+}
+

data/ext/congruence_solver/test/arith_utils_test.h

@@ -0,0 +1,25 @@
+#define NUM_OF_MOD_INV_TESTS 4
+#define NUM_OF_MOD_PRODUCT_TESTS 4
+#define NUM_OF_MOD_POWER_TESTS 4
+#define NUM_OF_COPRIME_TESTS 5
+#define NUM_OF_TOTIENT_TESTS 6
+#define NUM_OF_MOD_EVAL_POLYNOMIAL_TESTS 1
+
+int TOTIENT_NUMS[NUM_OF_TOTIENT_TESTS] = {1, 2, 3, 41, 125, 9400};
+int TOTIENT_EVALS[NUM_OF_TOTIENT_TESTS] = {1, 1, 2, 40, 100, 3680};
+
+int COPRIME_NUM_PAIRS[NUM_OF_COPRIME_TESTS][2] = {{3,5}, {9, 28}, {100, 34}, {1000512415, 557825}, {2286144, 1515839}};
+int COPRIME_EVALS[NUM_OF_COPRIME_TESTS] = {1, 1, 0, 0, 1};
+
+int MOD_PRODUCT_NUM_PAIRS[NUM_OF_MOD_PRODUCT_TESTS][2] = {{5,6}, {41,3}, {16, 98}, {105, 203}};
+int MOD_PRODUCT_MODS[NUM_OF_MOD_PRODUCT_TESTS] = {10, 8, 19, 98};
+int MOD_PRODUCT_PRODUCTS[NUM_OF_MOD_PRODUCT_TESTS] = {0, 3, 10, 49};
+
+int MOD_INV_NUMS[NUM_OF_MOD_INV_TESTS] = {5, 4, 53, 129};
+int MOD_INV_MODS[NUM_OF_MOD_INV_TESTS] = {12, 23, 105, 7};
+int MOD_INV_INVS[NUM_OF_MOD_INV_TESTS] = {5, 6, 2, 5};
+
+int MOD_POWER_NUMS[NUM_OF_MOD_POWER_TESTS] = {5, 19, 41, 100};
+int MOD_POWER_MODS[NUM_OF_MOD_POWER_TESTS] = {4, 23, 7, 33};
+int MOD_POWER_POWERS[NUM_OF_MOD_POWER_TESTS] = {10, 3, 4, 635};
+int MOD_POWER_EVALS[NUM_OF_MOD_POWER_TESTS] ={1, 5, 1, 1};

data/ext/congruence_solver/test/congruences_test.c

@@ -0,0 +1,78 @@
+#include <stdio.h>
+#include "../congruences.h"
+#include "congruences_test.h"
+
+void print_polynomial_inline(int func_degree, int * func_coeffs);
+int solve_congruence_test(int func_degree, int * func_coeffs, int mod, int num_of_solutions, int * solutions);
+
+int main(){
+	int failures = 0;
+
+	failures += solve_congruence_test(POL_1_DEGREE, POL_1_COEFFS, POL_1_MOD, NUM_OF_POL_1_SOLS, POL_1_SOLS);
+	failures += solve_congruence_test(POL_2_DEGREE, POL_2_COEFFS, POL_2_MOD, NUM_OF_POL_2_SOLS, POL_2_SOLS);
+	failures += solve_congruence_test(POL_3_DEGREE, POL_3_COEFFS, POL_3_MOD, NUM_OF_POL_3_SOLS, POL_3_SOLS);
+	failures += solve_congruence_test(POL_4_DEGREE, POL_4_COEFFS, POL_4_MOD, NUM_OF_POL_4_SOLS, POL_4_SOLS);
+	failures += solve_congruence_test(POL_5_DEGREE, POL_5_COEFFS, POL_5_MOD, NUM_OF_POL_5_SOLS, POL_5_SOLS);
+
+
+	return failures;
+}
+
+int int_array_cmp_func(const void * a, const void * b){
+	return *((int *)a) - *((int *) b);
+}
+
+int solve_congruence_test(int func_degree, int * func_coeffs, int mod, int num_of_solutions, int * solutions){
+	int * solutions_to_test = solve_congruence(func_degree, func_coeffs, mod);
+	int i, j;
+
+	qsort(solutions_to_test+1, solutions_to_test[0], sizeof(int), int_array_cmp_func);
+	qsort(solutions, num_of_solutions, sizeof(int), int_array_cmp_func);
+
+	if(num_of_solutions != solutions_to_test[0]){
+		printf("Incorrect number of solutions found for congruence ");
+		print_polynomial_inline(func_degree, func_coeffs);
+		printf(" = 0 (mod %d): %d given instead of %d.\n\n", mod, solutions_to_test[0], num_of_solutions);
+
+		printf("The following solutions were found: \n");
+		for(i = 0; i < solutions_to_test[0]; i++){
+			printf("(%d) %d\n", i, solutions_to_test[i+1]);
+		}
+
+		printf("\nwhere the actual solutions are\n\n");
+
+		for(i = 0; i < num_of_solutions; i++){
+			printf("(%d) %d\n", i, solutions[i]);
+		}
+
+		return 1;
+	}
+
+	for(i = 0; i < num_of_solutions; i++){
+		if(solutions[i] != solutions_to_test[i+1]){
+			printf("Incorrect %dth solution (after sorting) to congruence ", i);
+			
+			print_polynomial_inline(func_degree, func_coeffs);
+
+			printf(" = 0: %d given instead of %d.\n\n", solutions_to_test[i+1], solutions[i]);
+
+			return 1;
+		}
+	}
+
+	printf("Correct number of solutions (%d) found for congruence ", num_of_solutions);
+	print_polynomial_inline(func_degree, func_coeffs);
+	printf(" = 0 (mod %d) without error.\n\n", mod);
+
+	return 0;
+}
+
+void print_polynomial_inline(int func_degree, int * func_coeffs){
+	int j;
+
+	for(j = func_degree; j >= 1; j--){
+		printf("%d*x^%d + ", func_coeffs[j], j);
+	}
+
+	printf("%d", func_coeffs[0]);
+}

data/ext/congruence_solver/test/congruences_test.h

@@ -0,0 +1,204 @@
+#define POL_1_DEGREE 4
+#define POL_1_COEFF_0 0
+#define POL_1_COEFF_1 9
+#define POL_1_COEFF_2 0
+#define POL_1_COEFF_3 2
+#define POL_1_COEFF_4 1
+#define POL_1_MOD 99
+#define NUM_OF_POL_1_SOLS 12
+#define POL_1_SOL_0 0
+#define POL_1_SOL_1 6
+#define POL_1_SOL_2 30
+#define POL_1_SOL_3 33
+#define POL_1_SOL_4 39
+#define POL_1_SOL_5 52
+#define POL_1_SOL_6 61
+#define POL_1_SOL_7 63
+#define POL_1_SOL_8 66
+#define POL_1_SOL_9 72
+#define POL_1_SOL_10 88
+#define POL_1_SOL_11 96
+
+
+#define POL_2_DEGREE 6
+#define POL_2_COEFF_0 -1
+#define POL_2_COEFF_1 0
+#define POL_2_COEFF_2 0
+#define POL_2_COEFF_3 0
+#define POL_2_COEFF_4 0
+#define POL_2_COEFF_5 0
+#define POL_2_COEFF_6 1
+#define POL_2_MOD 700
+#define NUM_OF_POL_2_SOLS 24
+#define POL_2_SOL_0 1
+#define POL_2_SOL_1 51
+#define POL_2_SOL_2 99
+#define POL_2_SOL_3 101
+#define POL_2_SOL_4 149
+#define POL_2_SOL_5 151
+#define POL_2_SOL_6 199
+#define POL_2_SOL_7 201
+#define POL_2_SOL_8 249
+#define POL_2_SOL_9 251
+#define POL_2_SOL_10 299
+#define POL_2_SOL_11 349
+#define POL_2_SOL_12 351
+#define POL_2_SOL_13 401
+#define POL_2_SOL_14 449
+#define POL_2_SOL_15 451
+#define POL_2_SOL_16 499
+#define POL_2_SOL_17 501
+#define POL_2_SOL_18 549
+#define POL_2_SOL_19 551
+#define POL_2_SOL_20 599
+#define POL_2_SOL_21 601
+#define POL_2_SOL_22 649
+#define POL_2_SOL_23 699
+
+#define POL_3_DEGREE 9
+#define POL_3_COEFF_0 -11
+#define POL_3_COEFF_1 0
+#define POL_3_COEFF_2 0
+#define POL_3_COEFF_3 3
+#define POL_3_COEFF_4 0
+#define POL_3_COEFF_5 0
+#define POL_3_COEFF_6 0
+#define POL_3_COEFF_7 0
+#define POL_3_COEFF_8 0
+#define POL_3_COEFF_9 10
+#define POL_3_MOD 49
+#define NUM_OF_POL_3_SOLS 0
+
+#define POL_4_DEGREE 2
+#define POL_4_COEFF_0 4
+#define POL_4_COEFF_1 -4
+#define POL_4_COEFF_2 1
+#define POL_4_MOD 5104
+#define NUM_OF_POL_4_SOLS 4
+#define POL_4_SOL_0 2
+#define POL_4_SOL_1 1278
+#define POL_4_SOL_2 2554
+#define POL_4_SOL_3 3830
+
+#define POL_5_DEGREE 11
+#define POL_5_COEFF_0 0
+#define POL_5_COEFF_1 2
+#define POL_5_COEFF_2 0
+#define POL_5_COEFF_3 0
+#define POL_5_COEFF_4 0
+#define POL_5_COEFF_5 0
+#define POL_5_COEFF_6 0
+#define POL_5_COEFF_7 0
+#define POL_5_COEFF_8 0
+#define POL_5_COEFF_9 0
+#define POL_5_COEFF_10 0
+#define POL_5_COEFF_11 1
+#define POL_5_MOD 401249
+#define NUM_OF_POL_5_SOLS 9
+#define POL_5_SOL_0 0
+#define POL_5_SOL_1 87850
+#define POL_5_SOL_2 101665
+#define POL_5_SOL_3 105867
+#define POL_5_SOL_4 193717
+#define POL_5_SOL_5 207532
+#define POL_5_SOL_6 295382
+#define POL_5_SOL_7 299584
+#define POL_5_SOL_8 313399
+
+
+int POL_1_COEFFS[POL_1_DEGREE+1] = {POL_1_COEFF_0, 
+									POL_1_COEFF_1, 
+									POL_1_COEFF_2, 
+									POL_1_COEFF_3, 
+									POL_1_COEFF_4};
+int POL_1_SOLS[NUM_OF_POL_1_SOLS] = {POL_1_SOL_0, 
+									 POL_1_SOL_1, 
+									 POL_1_SOL_2, 
+									 POL_1_SOL_3, 
+									 POL_1_SOL_4, 
+									 POL_1_SOL_5, 
+									 POL_1_SOL_6, 
+									 POL_1_SOL_7, 
+									 POL_1_SOL_8, 
+									 POL_1_SOL_9, 
+									 POL_1_SOL_10, 
+									 POL_1_SOL_11};
+
+int POL_2_COEFFS[POL_2_DEGREE+1] = {POL_2_COEFF_0, 
+									POL_2_COEFF_1, 
+									POL_2_COEFF_2, 
+									POL_2_COEFF_3, 
+									POL_2_COEFF_4, 
+									POL_2_COEFF_5, 
+									POL_2_COEFF_6};
+
+int POL_2_SOLS[NUM_OF_POL_2_SOLS] = {POL_2_SOL_0, 
+								  	 POL_2_SOL_1, 
+								  	 POL_2_SOL_2, 
+								  	 POL_2_SOL_3, 
+								  	 POL_2_SOL_4, 
+								  	 POL_2_SOL_5, 
+								  	 POL_2_SOL_6, 
+								  	 POL_2_SOL_7, 
+									 POL_2_SOL_8, 
+									 POL_2_SOL_9, 
+									 POL_2_SOL_10, 
+									 POL_2_SOL_11, 
+									 POL_2_SOL_12, 
+									 POL_2_SOL_13, 
+									 POL_2_SOL_14, 
+									 POL_2_SOL_15, 
+									 POL_2_SOL_16, 
+									 POL_2_SOL_17, 
+									 POL_2_SOL_18, 
+									 POL_2_SOL_19, 
+									 POL_2_SOL_20, 
+									 POL_2_SOL_21, 
+									 POL_2_SOL_22,
+									 POL_2_SOL_23};
+
+int POL_3_COEFFS[POL_3_DEGREE+1] = {POL_3_COEFF_0,
+									POL_3_COEFF_1,
+									POL_3_COEFF_2,
+									POL_3_COEFF_3,
+									POL_3_COEFF_4,
+									POL_3_COEFF_5,
+									POL_3_COEFF_6,
+									POL_3_COEFF_7,
+									POL_3_COEFF_8,
+									POL_3_COEFF_9
+									};
+
+int * POL_3_SOLS = NULL;
+
+int POL_4_COEFFS[POL_4_DEGREE+1] = {POL_4_COEFF_0,
+									POL_4_COEFF_1,
+									POL_4_COEFF_2};
+
+int POL_4_SOLS[NUM_OF_POL_4_SOLS] = {POL_4_SOL_0,
+									POL_4_SOL_1,
+									POL_4_SOL_2,
+									POL_4_SOL_3};
+
+int POL_5_COEFFS[POL_5_DEGREE+1] = {POL_5_COEFF_0,
+									POL_5_COEFF_1,
+									POL_5_COEFF_2,
+									POL_5_COEFF_3,
+									POL_5_COEFF_4,
+									POL_5_COEFF_5,
+									POL_5_COEFF_6,
+									POL_5_COEFF_7,
+									POL_5_COEFF_8,
+									POL_5_COEFF_9,
+									POL_5_COEFF_10,
+									POL_5_COEFF_11};
+
+int POL_5_SOLS[NUM_OF_POL_5_SOLS] = {POL_5_SOL_0,
+									POL_5_SOL_1,
+									POL_5_SOL_2,
+									POL_5_SOL_3,
+									POL_5_SOL_4,
+									POL_5_SOL_5,
+									POL_5_SOL_6,
+									POL_5_SOL_7,
+									POL_5_SOL_8};

data/ext/congruence_solver/test/prime_gen_test.c

@@ -0,0 +1,83 @@
+#include <stdio.h>
+#include "../prime_gen.h"
+#include "prime_gen_test.h"
+
+
+
+int main(){
+  int failures = 0;
+  int i;
+  int * prime_ary_to_test = primes_upto(MAX_PRIME_FOR_PRIMES_UPTO_TEST)+1;
+
+  for(i=0; PRIME_ARY[i] <= MAX_PRIME_FOR_PRIMES_UPTO_TEST; i++){
+    if(PRIME_ARY[i] != prime_ary_to_test[i]){
+      printf("%dth prime incorrect: %d given instead of %d.\n\n", i, prime_ary_to_test[i], PRIME_ARY[i]);
+      failures += 1;
+    }
+  }
+
+  printf("Primes up to %d generated without error.\n\n", MAX_PRIME_FOR_PRIMES_UPTO_TEST);
+
+  prime_ary_to_test = primes(LIST_LENGTH_FOR_PRIMES_TEST);
+
+  for(i = 0; i < LIST_LENGTH_FOR_PRIMES_TEST; i++){
+    if(PRIME_ARY[i] != prime_ary_to_test[i]){
+      printf("%dth prime incorrect: %d given instead of %d.\n\n", i, prime_ary_to_test[i], PRIME_ARY[i]);
+      failures += 1;
+    }
+  }
+
+  printf("First %d primes generated without error.\n\n", LIST_LENGTH_FOR_PRIMES_TEST);
+ 
+  //Due to the implementation of prime generation and calculation of a maximum divisor
+  //2 (and 3, for the same reason) arises as a corner case
+  failures += prime_factors_test(2, FACTORS_OF_2, 1);
+
+  //Factorization of a prime should return an array containig a 1 followed by the prime itself.
+  failures += prime_factors_test(PRIME_TO_FACTOR, FACTORS_OF_PRIME, 1);
+
+  //Factorization of a  composite should return an array containing the number of factors and the 
+  //followed by the factors. 
+  failures += prime_factors_test(SMALL_COMPOSITE, FACTORS_OF_SMALL_COMPOSITE, NUM_OF_SMALL_COMPOSITE_FACTORS);
+
+  //Factorization of composites with factors to powers greater than 1 should still only list each factor once.
+  failures += prime_factors_test(COMPOSITE_WITH_REPEATED_FACTORS, REPEATED_FACTORS, NUM_OF_REPEATED_FACTORS); 
+
+  //Original implementation ran took several minutes to generate the primes necessary
+  //to factor large numbers.
+  printf("Beginning to factor a large composite number (%d). A stall here would indicate slow execution.\n",
+          LARGE_COMPOSITE);
+  failures += prime_factors_test(LARGE_COMPOSITE, FACTORS_OF_LARGE_COMPOSITE, NUM_OF_LARGE_COMPOSITE_FACTORS);
+
+  //Optimized implementation leverages the least prime factor (once discovered) to minimize the amount of prime generation necessary
+  //This method will still falter somewhat when the smallest prime factors are large.
+  printf("Beginning to factor a composite with no small prime factors (%d). A stall here would indicate slow execution.\n",
+          COMPOSITE_WITH_LARGE_FACTORS);
+  failures += prime_factors_test(COMPOSITE_WITH_LARGE_FACTORS, LARGE_FACTORS, NUM_OF_LARGE_FACTORS);
+
+  return failures;
+}
+
+
+int prime_factors_test(int num, int * expected_factors, int num_of_expected_factors){
+  int * factor_list = prime_factors(num);
+  int i;
+
+  if(factor_list[0] != num_of_expected_factors){
+    printf("Incorrect factorization of prime %d: %d factors given instead of %d.\n\n", num, factor_list[0], num_of_expected_factors);
+    return 1;
+  }
+
+  else{
+    for(i = 0; i < num_of_expected_factors; i++){
+      if(factor_list[i+1] != expected_factors[i]){
+        printf("Incorrect 0th factor of %d: %d given.\n\b", num, factor_list[1]);
+        return 1;
+      }
+    }
+  }
+
+  printf("%d factored correctly.\n\n", num);
+
+  return 0;
+}

data/ext/congruence_solver/test/prime_gen_test.h

@@ -0,0 +1,141 @@
+#define MAX_PRIME_FOR_PRIMES_UPTO_TEST 6000
+#define LIST_LENGTH_FOR_PRIMES_TEST 1000
+#define PRIME_TO_FACTOR 41
+
+#define SMALL_COMPOSITE 19110
+#define NUM_OF_SMALL_COMPOSITE_FACTORS 5
+#define SMALL_COMP_FACTOR_1 2
+#define SMALL_COMP_FACTOR_2 3
+#define SMALL_COMP_FACTOR_3 5
+#define SMALL_COMP_FACTOR_4 7
+#define SMALL_COMP_FACTOR_5 13
+
+#define LARGE_COMPOSITE 94122948
+#define NUM_OF_LARGE_COMPOSITE_FACTORS 5
+#define LARGE_COMP_FACTOR_1 2
+#define LARGE_COMP_FACTOR_2 3
+#define LARGE_COMP_FACTOR_3 17
+#define LARGE_COMP_FACTOR_4 223
+#define LARGE_COMP_FACTOR_5 2069
+
+#define COMPOSITE_WITH_REPEATED_FACTORS 108
+#define NUM_OF_REPEATED_FACTORS 2
+#define REPEATED_FACTOR_1 2
+#define REPEATED_FACTOR_2 3
+
+#define COMPOSITE_WITH_LARGE_FACTORS 24147371
+#define NUM_OF_LARGE_FACTORS 2
+#define LARGE_FACTOR_1 4909
+#define LARGE_FACTOR_2 4919
+
+const int PRIME_ARY[1000] = { 
+   2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 
+   31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 
+   73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 
+   127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 
+   179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 
+   233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 
+   283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 
+   353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 
+   419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 
+   467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 
+   547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 
+   607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 
+   661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 
+   739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 
+   811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 
+   877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 
+   947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 
+   1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 
+   1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 
+   1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 
+   1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 
+   1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 
+   1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 
+   1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 
+   1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 
+   1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 
+   1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 
+   1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 
+   1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 
+   1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 
+   1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 
+   2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 
+   2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 
+   2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 
+   2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 
+   2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 
+   2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 
+   2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 
+   2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 
+   2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 
+   2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 
+   2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 
+   2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 
+   3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 
+   3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 
+   3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 
+   3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 
+   3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 
+   3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 
+   3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 
+   3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 
+   3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 
+   3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 
+   3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 
+   3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 
+   4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 
+   4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 
+   4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 
+   4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 
+   4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 
+   4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 
+   4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 
+   4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 
+   4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 
+   4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 
+   4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 
+   4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 
+   5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 
+   5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 
+   5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 
+   5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 
+   5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 
+   5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 
+   5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 
+   5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 
+   5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 
+   5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 
+   5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 
+   5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 
+   6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 
+   6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 
+   6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 
+   6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 
+   6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 
+   6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 
+   6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 
+   6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 
+   6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 
+   6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 
+   6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 
+   7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 
+   7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 
+   7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 
+   7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 
+   7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 
+   7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 
+   7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 
+   7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 
+   7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 
+   7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 
+   };
+   
+const int FACTORS_OF_2[1] = {2};
+const int FACTORS_OF_PRIME[1] = {PRIME_TO_FACTOR};
+const int FACTORS_OF_SMALL_COMPOSITE[NUM_OF_SMALL_COMPOSITE_FACTORS] = {SMALL_COMP_FACTOR_1, SMALL_COMP_FACTOR_2, SMALL_COMP_FACTOR_3, 
+                                                            SMALL_COMP_FACTOR_4, SMALL_COMP_FACTOR_5};
+const int FACTORS_OF_LARGE_COMPOSITE[NUM_OF_LARGE_COMPOSITE_FACTORS] = {LARGE_COMP_FACTOR_1, LARGE_COMP_FACTOR_2, LARGE_COMP_FACTOR_3, 
+                                                            LARGE_COMP_FACTOR_4, LARGE_COMP_FACTOR_5};
+const int LARGE_FACTORS[NUM_OF_LARGE_FACTORS] = {LARGE_FACTOR_1, LARGE_FACTOR_2};
+const int REPEATED_FACTORS[NUM_OF_REPEATED_FACTORS] = {REPEATED_FACTOR_1, REPEATED_FACTOR_2};

data/lib/congruence_solver/version.rb

@@ -1,3 +1,3 @@
 module CongruenceSolver
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: congruence_solver
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - lane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-31 00:00:00.000000000 Z
+date: 2016-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -90,7 +90,22 @@ files:
 - bin/csolve.rb
 - bin/setup
 - congruence_solver.gemspec
+- ext/congruence_solver/.gitignore
+- ext/congruence_solver/Makefile
+- ext/congruence_solver/arith_utils.c
+- ext/congruence_solver/arith_utils.h
+- ext/congruence_solver/congruence_solver.c
+- ext/congruence_solver/congruences.c
+- ext/congruence_solver/congruences.h
 - ext/congruence_solver/extconf.rb
+- ext/congruence_solver/prime_gen.c
+- ext/congruence_solver/prime_gen.h
+- ext/congruence_solver/test/arith_utils_test.c
+- ext/congruence_solver/test/arith_utils_test.h
+- ext/congruence_solver/test/congruences_test.c
+- ext/congruence_solver/test/congruences_test.h
+- ext/congruence_solver/test/prime_gen_test.c
+- ext/congruence_solver/test/prime_gen_test.h
 - lib/congruence_solver.rb
 - lib/congruence_solver/version.rb
 - lib/polynomial_interpreter.rb