congruence_solver 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a5434d225bea224333675e4eba2a96f3642fa326
-  data.tar.gz: 14f70c00d5674fc1e260add8e9b5787463c29550
+  metadata.gz: 3add01a35c88d8001cd82b2548555e8823686167
+  data.tar.gz: e703f137d82640832dade1cddc55e327578eda3c
 SHA512:
-  metadata.gz: 4c3bf873aa8549385ded3cd7e9504cd36d4613b0645db636c4cda567af541dffdcfa33df756ef86a68723890fe05f0a2ea93fcdd5b5074e4d6289b9da92bb87b
-  data.tar.gz: bba1bc6e5ea41eb4220511d746e04cd995d094c086cd2594d10b82b399f0e8f1a6cc2a30a14d9efff6a27935e4ed173d45ffb9642bf3c031ba0c5fc524a2c61d
+  metadata.gz: d8e31f46ac56d4e4f3303363947078e53f307060c4c31359ac95e7c7b80c951db44cf2b4f81acf734a1beaad371f87d4009fe61bcc8ca196d60058349ded7f80
+  data.tar.gz: 07cdad5666f6fb71decfb1bdb304a9fd16cb7b9fe9d0c4ee211959927d98e04f2d41f837fdb7c6c641805a781197a1448f6f6ba00176411bb80d2ebbe4dfb858

data/README.md

@@ -4,7 +4,7 @@ CongruenceSolver is a gem for solving polynomial congruences. Should you ever ne
 
 ## Polynomial Congruences
 
-Polynomial congruences are the central topic of most elementary number theory and abstract algebra curricula. Similar to an equation, a [congruence](https://en.wikipedia.org/wiki/Modular_equation) is an [equivalence relation](https://en.wikipedia.org/wiki/Equivalence_relation) arising from [modular arithmetic](https://en.wikipedia.org/wiki/Modular_arithmetic) (also knowsn as "clock arithmetic"). For example, the idea "5 hours past 8 is 1" is expressed in the congruence ```8 + 5 = 1 mod 12```. A polynomial congruence is simply a congruence involving a polynomial, like ```x + 5 = 1 mod 12```. The problem of solving a congruence is to find all inputs satisfying the congruence, much like solving an equation (in this case, ```x = 8```). Generally speaking, congruences become more difficult to solve as the degree of the polynomial and the modulus grow. Elementary number theory develops tools like [Hensel Lifting](https://en.wikipedia.org/wiki/Hensel%27s_lemma#Hensel_Lifting) for solving polynomial congruences and the [Chinese Remainder Theorem](https://en.wikipedia.org/wiki/Chinese_remainder_theorem) for solving systems of polynomial congruences. This gem leverages these methods as implemented in C in [congruence_solver_ext](https://github.com/laneb/congruence_solver_ext).
+Polynomial congruences are the central topic of most elementary number theory and abstract algebra curricula. Similar to an equation, a [congruence](https://en.wikipedia.org/wiki/Modular_equation) is an [equivalence relation](https://en.wikipedia.org/wiki/Equivalence_relation) arising from [modular arithmetic](https://en.wikipedia.org/wiki/Modular_arithmetic) (also knowsn as "clock arithmetic"). For example, the idea "5 hours past 8 is 1" is expressed in the congruence ```8 + 5 = 1 mod 12```. A polynomial congruence is simply a congruence involving a polynomial, like ```x + 5 = 1 mod 12```. The problem of solving a congruence is to find all inputs satisfying the congruence, much like solving an equation (in this case, ```x = 8```). Generally speaking, congruences become more difficult to solve as the degree of the polynomial and the modulus grow. Elementary number theory develops tools like [Hensel Lifting](https://en.wikipedia.org/wiki/Hensel%27s_lemma#Hensel_Lifting) for solving polynomial congruences and the [Chinese Remainder Theorem](https://en.wikipedia.org/wiki/Chinese_remainder_theorem) for solving systems of polynomial congruences. This gem leverages these methods as implemented in C in [congruence_solver](https://github.com/laneb/congruence_solver).
 
 ## Installation
 
@@ -42,6 +42,10 @@ mod = 49
 CongruenceSolver.solve_congruence(coeffs, mod).sort  #=> [1, 8, 15, 22, 26, 29, 36, 43]
 ```
 
+## Limitations
+
+What are the limitations on the size of the numbers, you ask? CongruenceSolver can solve any congruence with a 16 bit degree that 32 bit coefficients and modulus. Of course, Ruby's Bignum can manage arbitrarily large integers without overflow, but the extension that powers has limitations to maintain speed and simplicity.
+
 ## Development
 
 First, install bundler (`gem install bundler`). Then install this project's dependencies with `bundle install`. Use `bundle exec rake update_ext` to pull and compile the extension. Use `bundle exec rake spec` to run the tests and `bundle exec rake bench` to run the benchmark. To build and install this gem locally, run `bundle exec rake install`.

data/Rakefile

@@ -5,7 +5,7 @@ require "os"
 
 def verbose_sh_exec(cmd)
   puts cmd
-  `#{cmd}`
+  system cmd
 end
 
 def verbose_rm_files(files_to_rm_ary)
@@ -20,14 +20,14 @@ end
 
 # runs the csolve binary
 task :exe do
-  system "bin/csolve"
+  verbose_sh_exec "bin/csolve"
 end
 
 #spec runs all RSpec examples
 RSpec::Core::RakeTask.new :spec
 
 # run the tests shipped the extension
-task :ctest => [:compile_ext] do
+task :ctest do
   verbose_sh_exec "(cd ext/congruence_solver && make test)"
 end
 
@@ -37,11 +37,12 @@ task :test => [:ctest, :spec]
 # workflow
 Rake::ExtensionTask.new 'congruence_solver' do |ext|
   ext.lib_dir = "lib/congruence_solver"
+  ext.config_options << "--openmp=-fopenmp"
 end
 
 # runs benchmarks
 task :bench do
-  system "csolve bench"
+  verbose_sh_exec "csolve bench"
 end
 
 # download source files for the extension
@@ -80,25 +81,27 @@ task :clean do
 end
 
 # build Ruby gem
-task :build => [:compile_ext] do
+task :build do
   gemspec = "congruence_solver.gemspec"
   verbose_sh_exec "gem build #{gemspec}"
 end
 
-# install gem locally
-task :install => [:clean, :update_ext, :test, :build] do
+def gemfile
   dot_gem_files = Dir.entries(Dir.pwd).select {|f| f =~ /congruence_solver\-.*\.gem/}
   if dot_gem_files.empty?
     STDERR.puts "Failed to build gem. Exiting."
   elsif dot_gem_files.length > 1
     STDERR.puts "Error: conflicting .gem files in directory. Exiting."
   else
-    verbose_sh_exec "gem install #{dot_gem_files.first}"
+    dot_gem_files.first
   end
 end
 
-task :publish do
-  cmd = "gem push *.gem"
-  p cmd
-  system cmd
+# install gem locally
+task :install => [:compile_ext, :build] do
+  verbose_sh_exec "gem install #{gemfile}"
+end
+
+task :publish => [:clean, :compile_ext, :test, :build] do
+  verbose_sh_exec "gem push #{gemfile}"
 end

data/bench/solve_congruence_bm.rb

@@ -2,70 +2,20 @@ require "congruence_solver"
 require "benchmark"
 require_relative "./bench_tools.rb"
 
+COEFFS = [-11, 0, 1, 3, 0, 5, 4, 180, 0, 10]
+COMPOSITE_MOD = 4837012493
+PRIME_MOD = 57081391
 
-SMALL_DEG_POLYNOMIAL_COEFFS = [1, -4, 4] 
-LARGE_DEG_POLYNOMIAL_COEFFS = [-11, 0, 0, 3, 0, 0, 0, 0, 0, 10]
-SMALL_MOD = 49
-MED_MOD = 5104
-LARGE_MOD = 94122
-XTRA_LARGE_MOD = 401249
-XTRA_LARGE_PRIME_MOD = 306893
-SMALL_FACTORED_LARGE_MOD = 510510
-
-
-def solve_congruence_brute_force(coeffs, mod)
-  solutions = []
-
-  0.upto(mod) do |x|
-    sum = 0
-
-    coeffs.each_with_index do |coe, exp|
-      sum = (sum + coe*x**exp) % mod
-    end
-
-    if sum == 0 then solutions << x end
-  end
-
-  solutions
-end
-
-
-def bm_solve_congruence(coeffs, mod) 
+def bm_solve_congruence(coeffs, mod)
     puts "Solving #{polynomial_to_s(coeffs)} = 0 mod #{mod}"
-
-    rb_bf_solutions = solve_congruence_brute_force(coeffs, mod).sort
-    #c_bf_solutions = CongruenceSolver.brute_force(coeffs, mod).sort
-    c_lifting_solutions = CongruenceSolver.lift(coeffs, mod).sort
-
-    unless rb_bf_solutions == c_lifting_solutions #and c_bf_solutions c_lift_solutions
-      puts "Solutions do not match:"
-      puts "Ruby/force solutions #{rb_bf_solutions.inspect}"
-      #puts "C/force solutions #{c_bf_solutions}"
-      puts "C/lifting solutions: #{c_lifting_solutions.inspect}"
-    end
-
-    puts "Time measurements:"
-
+    puts "Measurements:"
     Benchmark.bmbm do |bm|
-      bm.report("Ruby/force") do
-        solve_congruence_brute_force(coeffs, mod)
-      end
-=begin
-      bm.report("C/force") do
-        CongruenceSolver.brute_force(coeffs, mod)
-      end
-=end
       bm.report("C/lifting") do
         CongruenceSolver.lift(coeffs, mod)
       end
     end
-
     print "\n\n"
 end
 
-
-[SMALL_DEG_POLYNOMIAL_COEFFS, LARGE_DEG_POLYNOMIAL_COEFFS].each do |coeffs|
-  [SMALL_MOD, MED_MOD, LARGE_MOD, XTRA_LARGE_MOD, XTRA_LARGE_PRIME_MOD, SMALL_FACTORED_LARGE_MOD].each do |mod|
-    bm_solve_congruence(coeffs, mod)
-  end
-end
+bm_solve_congruence(COEFFS,COMPOSITE_MOD)
+bm_solve_congruence(COEFFS,PRIME_MOD)

data/congruence_solver.gemspec

@@ -24,9 +24,9 @@ Gem::Specification.new do |spec|
 
   spec.extensions << "ext/congruence_solver/extconf.rb"
 
-  spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "bundler", "~>1.10"
+  spec.add_development_dependency "rake", "~>10.0"
+  spec.add_development_dependency "rspec", "~>3.0"
   spec.add_development_dependency "rake-compiler", "~>0.9"
   spec.add_development_dependency "os", "~>0.9"
 end

data/ext/congruence_solver/Makefile

@@ -1,12 +1,13 @@
+CC = gcc-6 -fopenmp -std=c99
 
 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
+	$(CC) -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
+	$(CC) -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
+	$(CC) -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

data/ext/congruence_solver/arith_utils.c

@@ -4,7 +4,7 @@
 #include "arith_utils.h"
 
 //Expects 0 <= x,y < mod
-int mod_sum(int x, int y, int mod){
+long mod_sum(long x, long y, long mod){
 	if(y >= mod - x){
 		return y - (mod - x);
 	}
@@ -15,8 +15,8 @@ int mod_sum(int x, int y, int mod){
 }
 
 
-int mod_inv(int n, int mod){
-	int y, a;
+long mod_inv(long n, long mod){
+	long y, a;
 
 	if(n!=0){
 
@@ -37,30 +37,9 @@ int mod_inv(int n, int mod){
 }
 
 
-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;
+long mod_product(long num1, long num2, long mod){
+	long prod = 0;
+	long i;
 
 	for(i = 0; i < num1; i++){
 		prod = mod_sum(prod, num2, mod);
@@ -69,68 +48,15 @@ int mod_product(int num1, int num2, int mod){
 	return prod;
 }
 
-//expects 0 <= n < mod
-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){
-	long tot = coeffs[degree];
+long mod_eval_polynomial(int degree, long coeffs[], long mod, long x){
+	long long tot = coeffs[degree];
 	int i;
 
 	for(i = degree - 1; i >= 0; i--){
-		tot = (x*tot) % mod;
-		tot = (tot + coeffs[i]) % mod;
+		tot = ( (long long) tot*x ) % mod;
+		tot = ( (long long) tot + coeffs[i] ) % mod;
 	}
 
-	return (int) tot;
+	return (long) tot;
 }
-
-
-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

@@ -1,10 +1,6 @@
 #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
+long mod_inv(long n, long mod);
+long mod_product(long n1, long n2, long mod);
+long mod_eval_polynomial(int degree, long coeffs[], long mod, long x);
+#endif

data/ext/congruence_solver/congruence_solver.c

@@ -9,77 +9,70 @@ 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", 
+  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;
+  long * longSolutions;
   VALUE rbSolutions;
-  int intMod = NUM2INT(mod);
+  long longMod = NUM2LONG(mod);
 
   int intFuncDegree = RARRAY_LEN(funcCoeffs)-1;
-  int * intFuncCoeffs = calloc(intFuncDegree+1, sizeof(int));
+  long * longFuncCoeffs = calloc(intFuncDegree+1, sizeof(long));
 
   for(i = 0; i <= intFuncDegree; i++){
-    intFuncCoeffs[i] = NUM2INT(rb_ary_entry(funcCoeffs, i));
+    longFuncCoeffs[i] = NUM2LONG(rb_ary_entry(funcCoeffs, i));
   }
 
-  intSolutions = brute_force_congruence(intFuncDegree, intFuncCoeffs, intMod);
-  rbSolutions = rb_ary_new2(intSolutions[0]);
+  longSolutions = brute_force_congruence(intFuncDegree, longFuncCoeffs, longMod);
+  rbSolutions = rb_ary_new2(longSolutions[0]);
 
-  for(i=0; i<intSolutions[0]; i++){
-    rb_ary_store(rbSolutions, i, INT2NUM(intSolutions[i+1]));
+  for(i=0; i<longSolutions[0]; i++){
+    rb_ary_store(rbSolutions, i, LONG2NUM(longSolutions[i+1]));
   }
 
 
-  free(intFuncCoeffs);
-  free(intSolutions);
+  free(longFuncCoeffs);
+  free(longSolutions);
 
   return rbSolutions;
 }
- 
+
 
 VALUE method_congruence_solver_lift(VALUE self, VALUE funcCoeffs, VALUE mod){
   int i;
-  int * intSolutions;
+  long * longSolutions;
   VALUE rbSolutions;
-  int intMod = NUM2INT(mod);
+  long longMod = NUM2LONG(mod);
 
   int intFuncDegree = RARRAY_LEN(funcCoeffs)-1;
-  int * intFuncCoeffs = calloc(intFuncDegree+1, sizeof(int));
+  long * longFuncCoeffs = calloc(intFuncDegree+1, sizeof(long));
 
   for(i=0; i<=intFuncDegree; i++){
-    intFuncCoeffs[i] = NUM2INT(rb_ary_entry(funcCoeffs, i));
+    longFuncCoeffs[i] = NUM2LONG(rb_ary_entry(funcCoeffs, i));
   }
 
+  longSolutions = solve_congruence(intFuncDegree, longFuncCoeffs, longMod);
 
-  intSolutions = solve_congruence(intFuncDegree, intFuncCoeffs, intMod);
-  rbSolutions = rb_ary_new2(intSolutions[0]);
+  rbSolutions = rb_ary_new2(longSolutions[0]);
 
-  for(i=0; i<intSolutions[0]; i++){
-    rb_ary_store(rbSolutions, i, INT2NUM(intSolutions[i+1]));
+  for(i=0; i<longSolutions[0]; i++){
+    rb_ary_store(rbSolutions, i, LONG2NUM(longSolutions[i+1]));
   }
 
 
-  free(intFuncCoeffs);
-  free(intSolutions);
+  free(longFuncCoeffs);
+  free(longSolutions);
 
   return rbSolutions;
 }
-

data/ext/congruence_solver/congruences.c

@@ -3,15 +3,15 @@
 #include <stdlib.h>
 #include <stdio.h>
 
-static int * adjust_coeffs_to_mod(int degree, int * coeffs, int mod);
-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[]);
+static long * adjust_coeffs_to_mod(int degree, long * coeffs, long mod);
+static long * solve_prime_power_congruence(int degree, long coeffs[], long prime, int power);
+static long * solve_system_of_order_1_congruence_sets(int numOfSets, int * lengthsOfSets, long ** sets, long mods[]);
 
-int chinese_remainder_solution(int numberOfEquations, int scals[], int mods[]){
+long chinese_remainder_solution(int numberOfEquations, long scals[], long mods[]){
   int i;
-  int x = 0;
-  int m = mods[0];
-  int modCoeff;
+  long long x = 0;
+  long m = mods[0];
+  long modCoeff;
 
   for(i=1; i<numberOfEquations; i++){
     m *= mods[i];
@@ -19,15 +19,16 @@ int chinese_remainder_solution(int numberOfEquations, int scals[], int mods[]){
 
   for(i=0; i<numberOfEquations; i++){
     modCoeff = m/mods[i];
-    x += modCoeff*mod_inv(modCoeff % mods[i], mods[i])*scals[i];
+    x += (long long) modCoeff*mod_inv(modCoeff % mods[i], mods[i])*scals[i] % m;
+    x %= m;
   }
 
   return x % m;
 }
 
 
-int * adjust_coeffs_to_mod(int degree, int * coeffs, int mod){
-  int * adjustedCoeffs = calloc(degree+1, sizeof(int));
+long * adjust_coeffs_to_mod(int degree, long * coeffs, long mod){
+  long * adjustedCoeffs = calloc(degree+1, sizeof(long));
   int i;
 
   for(i = 0; i <= degree; i++){
@@ -41,19 +42,19 @@ int * adjust_coeffs_to_mod(int degree, int * coeffs, int mod){
 }
 
 
-int * brute_force_congruence(int degree, int coeffs[], int primeMod){
+long * brute_force_congruence(int degree, long coeffs[], long 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
   //also assumes positive representation of coeffs
-  int * adjustedCoeffs = adjust_coeffs_to_mod(degree, coeffs, primeMod);
-  int * solutionList = calloc(degree+1, sizeof(int));
-  int * solutions = solutionList+1;
+  long * adjustedCoeffs = adjust_coeffs_to_mod(degree, coeffs, primeMod);
+  long * solutionList = calloc(degree+1, sizeof(long));
+  long * solutions = solutionList+1;
   int numberOfSolutions = 0;
-  int x;
+  long x;
 
-
-  for(x = 0; x < primeMod && numberOfSolutions <= degree; x++){
+  #pragma omp parallel for
+  for(x = 0; x < primeMod; x++){
     if(mod_eval_polynomial(degree, adjustedCoeffs, primeMod, x) == 0){
       solutions[numberOfSolutions++] = x;
     }
@@ -67,26 +68,23 @@ int * brute_force_congruence(int degree, int coeffs[], int primeMod){
 }
 
 
-static int * solve_prime_power_congruence(int funcDegree, int funcCoeffs[], int prime, int power){
-
-  int * adjustedCoeffs;
-
-  int * baseSolutionList;
+static long * solve_prime_power_congruence(int funcDegree, long funcCoeffs[], long prime, int power){
+  long * baseSolutionList;
   int numOfBaseSolutions;
-  int * baseSolutions;
+  long * baseSolutions;
 
-  int * liftedSolutions;
+  long * liftedSolutions;
   int numOfLiftedSolutions;
 
-  int coeff;
+  long coeff;
 
   int derivDegree;
-  int * derivCoeffs;
-  int deriv;
-  long int divFunc;
+  long * derivCoeffs;
+  long deriv;
+  long func;
 
   int i, j, t;
-  int currentMod;
+  long currentMod;
 
   if(power == 1){
     baseSolutions = brute_force_congruence(funcDegree, funcCoeffs, prime);
@@ -97,11 +95,11 @@ static int * solve_prime_power_congruence(int funcDegree, int funcCoeffs[], int
   numOfBaseSolutions = *baseSolutionList;
   baseSolutions = baseSolutionList+1;
 
-  liftedSolutions = calloc(prime*numOfBaseSolutions+1, sizeof(int));
+  liftedSolutions = calloc(prime*numOfBaseSolutions+1, sizeof(long));
   numOfLiftedSolutions = 0;
 
   derivDegree = funcDegree-1;
-  derivCoeffs = calloc(derivDegree+1, sizeof(int));
+  derivCoeffs = calloc(derivDegree+1, sizeof(long));
 
   currentMod = prime;
   for(j = 1; j < power; j++){
@@ -120,14 +118,14 @@ static int * solve_prime_power_congruence(int funcDegree, int funcCoeffs[], int
   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;
+    func = mod_eval_polynomial(funcDegree, funcCoeffs, currentMod, baseSolutions[j]);
 
     if(deriv % prime != 0){
-      t = (-divFunc*mod_inv(deriv, prime) % prime) + prime;
+      t = ((-func / (currentMod/prime))*mod_inv(deriv, currentMod) % prime) + prime;
       liftedSolutions[++numOfLiftedSolutions] = baseSolutions[j] + t*prime;
     }
 
-    else if(divFunc % prime == 0){
+    else if(func == 0){
       for(t = 1; t <= prime; t++){
         liftedSolutions[++numOfLiftedSolutions] = baseSolutions[j] + t*(currentMod/prime);
       }
@@ -144,14 +142,14 @@ static int * solve_prime_power_congruence(int funcDegree, int funcCoeffs[], int
 }
 
 
-static int * solve_system_of_order_1_congruence_sets(int numOfSets, int * setLengths, int * * sets, int * mods){
+static long * solve_system_of_order_1_congruence_sets(int numOfSets, int * setLengths, long * * sets, long * mods){
   //allocate perumtation array
-  int * divAry = calloc(numOfSets, sizeof(int));
-  int * scalAry = calloc(numOfSets, sizeof(int));
+  long * divAry = calloc(numOfSets, sizeof(long));
+  long * scalAry = calloc(numOfSets, sizeof(long));
   int i, j;
   int numOfSolutions;
-  int * solutionAry;
-  int * dest;
+  long * solutionAry;
+  long * dest;
   int idx;
 
   for(i = 0, numOfSolutions = 1; i < numOfSets; i++){
@@ -159,7 +157,7 @@ static int * solve_system_of_order_1_congruence_sets(int numOfSets, int * setLen
     numOfSolutions *= setLengths[i];
   }
 
-  solutionAry = calloc(numOfSolutions+1, sizeof(int));
+  solutionAry = calloc(numOfSolutions+1, sizeof(long));
   solutionAry[0] = numOfSolutions;
   dest = solutionAry+1;
 
@@ -175,24 +173,24 @@ static int * solve_system_of_order_1_congruence_sets(int numOfSets, int * setLen
   return solutionAry;
 }
 
-int * solve_congruence(int funcDegree, int funcCoeffs[], int mod){
-  int * solutionList;
+long * solve_congruence(int funcDegree, long funcCoeffs[], long mod){
+  long * solutionList;
 
-  int * modFactorList = prime_factors(mod);
-  int numOfModFactors = *modFactorList;
-  int * modFactors = modFactorList+1;
+  long * modFactorList = prime_factors(mod);
+  long numOfModFactors = *modFactorList;
+  long * modFactors = modFactorList+1;
 
-  int * * primePowerSolutions = calloc(numOfModFactors, sizeof(int *));
-  int * primePowers = calloc(numOfModFactors, sizeof(int));
+  long * * primePowerSolutions = calloc(numOfModFactors, sizeof(long *));
+  long * primePowers = calloc(numOfModFactors, sizeof(long));
   int * primePowerSolutionLengths = calloc(numOfModFactors, sizeof(int *));
 
   int power;
-  int i;
+  int i,j,k;
 
   for(i = 0; i < numOfModFactors; i++){
-    primePowers[i] = modFactors[i]; 
+    primePowers[i] = modFactors[i];
     power = 1;
-    
+
     while(mod % (primePowers[i]*modFactors[i]) == 0){
       primePowers[i] *= modFactors[i];
       power++;
@@ -214,14 +212,3 @@ int * solve_congruence(int funcDegree, int funcCoeffs[], int mod){
 
   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

@@ -1,7 +1,6 @@
 #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
+long chinese_remainder_solution(int numOfEquations, int long[], long mods[]);
+long * solve_congruence(int funcDegree, long funcCoeffs[], long mod);
+long * brute_force_congruence(int degree, long coeffs[], long primeMod);
+#endif

data/ext/congruence_solver/extconf.rb

@@ -13,4 +13,14 @@ EXT_C = %w[
 	prime_gen.c
 ]
 
-create_makefile "congruence_solver/congruence_solver"
+omp_opt = arg_config("--openmp")
+if omp_opt
+	if have_header("omp.h")
+		$CFLAGS += " " + omp_opt
+		$DLDFLAGS += " " + omp_opt
+	else
+		raise "OpenMP unsupported by this compiler"
+	end
+end
+
+create_makefile "congruence_solver/congruence_solver"

data/ext/congruence_solver/prime_gen.c

@@ -7,40 +7,40 @@
 #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 void expand_prime_list_past(long max);
+static int any_divisors(long * div_list, int length, long num);
+static long least_divisor(long n);
 
-static int * PRIME_LIST = NULL;
+static long * PRIME_LIST = NULL;
 static int PRIME_LIST_LENGTH = 0;
 static int PRIME_LIST_MAX_LENGTH = 0;
-static int NEXT_INTEGER = FIRST_PRIME;
+static long NEXT_INTEGER = FIRST_PRIME;
 
 
-int * primes(int length){
-	int * rtrn_list = calloc(length, sizeof(int));
+long * primes(int length){
+	long * rtrn_list = calloc(length, sizeof(long));
 
 	expand_prime_list_to_length(length);
 
 	if(rtrn_list != NULL){
-		memcpy(rtrn_list, PRIME_LIST, length*sizeof(int));
+		memcpy(rtrn_list, PRIME_LIST, length*sizeof(long));
 	}
 
 	return rtrn_list;
 }
 
 
-int * primes_upto(int max){
-	int * rtrn_list;
+long * primes_upto(long max){
+	long * 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 = calloc(i+1, sizeof(long));
 			rtrn_list[0] = i;
-			memcpy(rtrn_list+1, PRIME_LIST, i*sizeof(int));
+			memcpy(rtrn_list+1, PRIME_LIST, i*sizeof(long));
 			return rtrn_list;
 		}
 	}
@@ -49,14 +49,14 @@ int * primes_upto(int max){
 }
 
 
-int * prime_factors(int n){
-	int * rtrn_list = malloc(sizeof(int));
+long * prime_factors(long n){
+	long * rtrn_list = malloc(sizeof(long));
 	int rtrn_list_length = 0;
-	int least_div;
+	long least_div;
 
 	while(n != 1){
 		least_div = least_divisor(n);
-		rtrn_list = realloc(rtrn_list, (rtrn_list_length+2)*sizeof(int));
+		rtrn_list = realloc(rtrn_list, (rtrn_list_length+2)*sizeof(long));
 		rtrn_list[++rtrn_list_length] = least_div;
 
 		if(least_div == n){
@@ -74,9 +74,9 @@ int * prime_factors(int n){
 }
 
 
-static int least_divisor(int n){
+static long least_divisor(long n){
 	//Calculate maximum for least divisor (sqrt)
-	int least_div_max = sqrt(n) + 1;
+	long least_div_max = sqrt(n) + 1;
 	int i;
 	//Expand prime list up to the least divisor
 	expand_prime_list_past(least_div_max);
@@ -96,7 +96,7 @@ 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));
+		PRIME_LIST = realloc(PRIME_LIST, PRIME_LIST_MAX_LENGTH*sizeof(long));
 	}
 
 	while(PRIME_LIST_LENGTH < length){
@@ -110,15 +110,15 @@ static void expand_prime_list_to_length(int length){
 }
 
 
-static void expand_prime_list_past(int max){
+static void expand_prime_list_past(long 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 = calloc(PRIME_LIST_MAX_LENGTH, sizeof(long));
 		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++;
@@ -126,7 +126,7 @@ static void expand_prime_list_past(int max){
 
 		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 = realloc(PRIME_LIST, PRIME_LIST_MAX_LENGTH*sizeof(long));
 		}
 
 		PRIME_LIST[PRIME_LIST_LENGTH++] = NEXT_INTEGER;
@@ -134,7 +134,7 @@ static void expand_prime_list_past(int max){
 }
 
 
-static int any_divisors(int * div_list, int length, int num){
+static int any_divisors(long * div_list, int length, long num){
 	int i;
 	for(i = 0; i < length; i++){
 		if(num % div_list[i] == 0){

data/ext/congruence_solver/prime_gen.h

@@ -1,10 +1,10 @@
 #ifndef H_PRIME_GEN
 #define H_PRIME_GEN
-int * primes(int n);
+long * primes(int length);
 
-//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 
+//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
+long * primes_upto(long max);
+long * prime_factors(long n);
+#endif

data/lib/congruence_solver/version.rb

@@ -1,3 +1,3 @@
 module CongruenceSolver
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: congruence_solver
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - lane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-26 00:00:00.000000000 Z
+date: 2017-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler