prime_sieve 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4f8cbfde40f177077ab71f59b186bb4cf29a3c44
+  data.tar.gz: 5de440372c422105f0a2aed7d90d2c22eee096f4
+SHA512:
+  metadata.gz: 430633f078e2a7688fc0be914269cf4c3c2ca65e67d931c108e22901bd9ddecdf2449bec5ec5504b4548aa2e94995c57eca3cb2f6b65ddf4f648b9225c883e42
+  data.tar.gz: 3b02746a0e5a6ff087549eb856bd3ef4c1be44b47d8704a339a80fde4d1a90836dfeeaded9425fbb394c488565a0ceef788499b7807506d830a1b408c4fee7f5

data/ext/prime_sieve/extconf.rb

@@ -0,0 +1,63 @@
+require "mkmf"
+
+LIBDIR     = RbConfig::CONFIG['libdir']
+INCLUDEDIR = RbConfig::CONFIG['includedir']
+
+HEADER_DIRS = [
+  '/usr/local/include',
+  INCLUDEDIR,
+  '/usr/include',
+]
+
+LIB_DIRS = [
+  '/usr/local/lib',
+  LIBDIR,
+  '/usr/lib',
+]
+
+dir_config('primesieve', HEADER_DIRS, LIB_DIRS)
+
+fns = [
+ 'primesieve_generate_primes',
+ 'primesieve_generate_n_primes',
+ 'primesieve_nth_prime',
+ 'primesieve_parallel_nth_prime',
+ 'primesieve_count_primes',
+ 'primesieve_count_twins',
+ 'primesieve_count_triplets',
+ 'primesieve_count_quadruplets',
+ 'primesieve_count_quintuplets',
+ 'primesieve_count_sextuplets',
+ 'primesieve_parallel_count_primes',
+ 'primesieve_parallel_count_twins',
+ 'primesieve_parallel_count_triplets',
+ 'primesieve_parallel_count_quadruplets',
+ 'primesieve_parallel_count_quintuplets',
+ 'primesieve_parallel_count_sextuplets',
+ 'primesieve_print_primes',
+ 'primesieve_print_twins',
+ 'primesieve_print_triplets',
+ 'primesieve_print_quadruplets',
+ 'primesieve_print_quintuplets',
+ 'primesieve_print_sextuplets',
+ 'primesieve_callback_primes',
+ 'primesieve_parallel_callback_primes',
+ 'primesieve_get_sieve_size',
+ 'primesieve_get_num_threads',
+ 'primesieve_get_max_stop',
+ 'primesieve_set_sieve_size',
+ 'primesieve_set_num_threads',
+ 'primesieve_test'
+]
+
+unless find_header('primesieve.h')
+  abort 'primesieve header is missing. please install primesieve'
+end
+
+fns.each do |fn|
+  unless find_library('primesieve', fn)
+    abort "primesieve library is missing. could not find function #{fn}. please install primesieve"
+  end
+end
+
+create_makefile("prime_sieve/prime_sieve")

data/ext/prime_sieve/prime_sieve.c

@@ -0,0 +1,195 @@
+#include <prime_sieve.h>
+
+VALUE mPrimeSieve;
+
+static VALUE generate_primes(VALUE self, VALUE start, VALUE stop) {
+  size_t size;
+  uint64_t* primes = (uint64_t *) primesieve_generate_primes(NUM2ULL(start), NUM2ULL(stop), &size, UINT64_PRIMES);
+  VALUE ruby_primes = rb_ary_new2(size);
+  for(size_t i = 0; i < size; i++) {
+    rb_ary_store(ruby_primes, i, ULL2NUM(primes[i]));
+  }
+  primesieve_free(primes);
+  return ruby_primes;
+}
+
+static VALUE generate_n_primes(VALUE self, VALUE n, VALUE start) {
+  uint64_t* primes = (uint64_t *) primesieve_generate_n_primes(NUM2ULL(n), NUM2ULL(start), UINT64_PRIMES);
+  VALUE ruby_primes = rb_ary_new2(NUM2LONG(n));
+  for(long i = 0; i < NUM2LONG(n); i++) {
+    rb_ary_store(ruby_primes, i, ULL2NUM(primes[i]));
+  }
+  primesieve_free(primes);
+  return ruby_primes;
+}
+
+static VALUE nth_prime(VALUE self, VALUE n, VALUE start) {
+  return ULL2NUM(primesieve_nth_prime(NUM2LL(n), NUM2ULL(start)));
+}
+
+static VALUE parallel_nth_prime(VALUE self, VALUE n, VALUE start) {
+  return ULL2NUM(primesieve_parallel_nth_prime(NUM2LL(n), NUM2ULL(start)));
+}
+
+static VALUE count_primes(VALUE self, VALUE start, VALUE stop) {
+  return ULL2NUM(primesieve_count_primes(NUM2ULL(start), NUM2ULL(stop)));
+}
+
+static VALUE count_twins(VALUE self, VALUE start, VALUE stop) {
+  return ULL2NUM(primesieve_count_twins(NUM2ULL(start), NUM2ULL(stop)));
+}
+
+static VALUE count_triplets(VALUE self, VALUE start, VALUE stop) {
+  return ULL2NUM(primesieve_count_triplets(NUM2ULL(start), NUM2ULL(stop)));
+}
+
+static VALUE count_quadruplets(VALUE self, VALUE start, VALUE stop) {
+  return ULL2NUM(primesieve_count_quadruplets(NUM2ULL(start), NUM2ULL(stop)));
+}
+
+static VALUE count_quintuplets(VALUE self, VALUE start, VALUE stop) {
+  return ULL2NUM(primesieve_count_quintuplets(NUM2ULL(start), NUM2ULL(stop)));
+}
+
+static VALUE count_sextuplets(VALUE self, VALUE start, VALUE stop) {
+  return ULL2NUM(primesieve_count_sextuplets(NUM2ULL(start), NUM2ULL(stop)));
+}
+
+static VALUE parallel_count_primes(VALUE self, VALUE start, VALUE stop) {
+  return ULL2NUM(primesieve_parallel_count_primes(NUM2ULL(start), NUM2ULL(stop)));
+}
+
+static VALUE parallel_count_twins(VALUE self, VALUE start, VALUE stop) {
+  return ULL2NUM(primesieve_parallel_count_twins(NUM2ULL(start), NUM2ULL(stop)));
+}
+
+static VALUE parallel_count_triplets(VALUE self, VALUE start, VALUE stop) {
+  return ULL2NUM(primesieve_parallel_count_triplets(NUM2ULL(start), NUM2ULL(stop)));
+}
+
+static VALUE parallel_count_quadruplets(VALUE self, VALUE start, VALUE stop) {
+  return ULL2NUM(primesieve_parallel_count_quadruplets(NUM2ULL(start), NUM2ULL(stop)));
+}
+
+static VALUE parallel_count_quintuplets(VALUE self, VALUE start, VALUE stop) {
+  return ULL2NUM(primesieve_parallel_count_quintuplets(NUM2ULL(start), NUM2ULL(stop)));
+}
+
+static VALUE parallel_count_sextuplets(VALUE self, VALUE start, VALUE stop) {
+  return ULL2NUM(primesieve_parallel_count_sextuplets(NUM2ULL(start), NUM2ULL(stop)));
+}
+
+static VALUE print_primes(VALUE self, VALUE start, VALUE stop) {
+  primesieve_print_primes(NUM2ULL(start), NUM2ULL(stop));
+  return Qnil;
+}
+
+static VALUE print_twins(VALUE self, VALUE start, VALUE stop) {
+  primesieve_print_twins(NUM2ULL(start), NUM2ULL(stop));
+  return Qnil;
+}
+
+static VALUE print_triplets(VALUE self, VALUE start, VALUE stop) {
+  primesieve_print_triplets(NUM2ULL(start), NUM2ULL(stop));
+  return Qnil;
+}
+
+static VALUE print_quadruplets(VALUE self, VALUE start, VALUE stop) {
+  primesieve_print_quadruplets(NUM2ULL(start), NUM2ULL(stop));
+  return Qnil;
+}
+
+static VALUE print_quintuplets(VALUE self, VALUE start, VALUE stop) {
+  primesieve_print_quintuplets(NUM2ULL(start), NUM2ULL(stop));
+  return Qnil;
+}
+
+static VALUE print_sextuplets(VALUE self, VALUE start, VALUE stop) {
+  primesieve_print_sextuplets(NUM2ULL(start), NUM2ULL(stop));
+  return Qnil;
+}
+
+static void callback_fn(uint64_t prime) {
+  rb_yield(ULL2NUM(prime));
+  return;
+}
+
+static VALUE callback_primes(VALUE self, VALUE start, VALUE stop) {
+  if (!rb_block_given_p())
+    rb_raise(rb_eArgError, "Expected block");
+  primesieve_callback_primes(NUM2ULL(start), NUM2ULL(stop), callback_fn);
+  return Qnil;
+}
+
+static void parallel_callback_fn(uint64_t prime, int thread_id) {
+  rb_yield_values(2, ULL2NUM(prime), INT2NUM(thread_id));
+  return;
+}
+
+static VALUE parallel_callback_primes(VALUE self, VALUE start, VALUE stop) {
+  if (!rb_block_given_p())
+    rb_raise(rb_eArgError, "Expected block");
+  primesieve_parallel_callback_primes(NUM2ULL(start), NUM2ULL(stop), parallel_callback_fn);
+  return Qnil;
+}
+
+static VALUE get_sieve_size(VALUE self) {
+  return INT2NUM(primesieve_get_sieve_size());
+}
+
+static VALUE get_num_threads(VALUE self) {
+  return INT2NUM(primesieve_get_num_threads());
+}
+
+static VALUE get_max_stop(VALUE self) {
+  return ULL2NUM(primesieve_get_max_stop());
+}
+
+static VALUE set_sieve_size(VALUE self, VALUE sieve_size) {
+  primesieve_set_sieve_size(NUM2INT(sieve_size));
+  return Qnil;
+}
+
+static VALUE set_num_threads(VALUE self, VALUE num_threads) {
+  primesieve_set_num_threads(NUM2INT(num_threads));
+  return Qnil;
+}
+
+static VALUE test(VALUE self) {
+  return INT2NUM(primesieve_test());
+}
+
+void Init_prime_sieve() {
+  mPrimeSieve = rb_define_module("PrimeSieve");
+
+  rb_define_module_function(mPrimeSieve, "generate_primes", generate_primes, 2);
+  rb_define_module_function(mPrimeSieve, "generate_n_primes", generate_n_primes, 2);
+  rb_define_module_function(mPrimeSieve, "nth_prime", nth_prime, 2);
+  rb_define_module_function(mPrimeSieve, "parallel_nth_prime", parallel_nth_prime, 2);
+  rb_define_module_function(mPrimeSieve, "count_primes", count_primes, 2);
+  rb_define_module_function(mPrimeSieve, "count_twins", count_twins, 2);
+  rb_define_module_function(mPrimeSieve, "count_triplets", count_triplets, 2);
+  rb_define_module_function(mPrimeSieve, "count_quadruplets", count_quadruplets, 2);
+  rb_define_module_function(mPrimeSieve, "count_quintuplets", count_quintuplets, 2);
+  rb_define_module_function(mPrimeSieve, "count_sextuplets", count_sextuplets, 2);
+  rb_define_module_function(mPrimeSieve, "parallel_count_primes", parallel_count_primes, 2);
+  rb_define_module_function(mPrimeSieve, "parallel_count_twins", parallel_count_twins, 2);
+  rb_define_module_function(mPrimeSieve, "parallel_count_triplets", parallel_count_triplets, 2);
+  rb_define_module_function(mPrimeSieve, "parallel_count_quadruplets", parallel_count_quadruplets, 2);
+  rb_define_module_function(mPrimeSieve, "parallel_count_quintuplets", parallel_count_quintuplets, 2);
+  rb_define_module_function(mPrimeSieve, "parallel_count_sextuplets", parallel_count_sextuplets, 2);
+  rb_define_module_function(mPrimeSieve, "print_primes", print_primes, 2);
+  rb_define_module_function(mPrimeSieve, "print_twins", print_twins, 2);
+  rb_define_module_function(mPrimeSieve, "print_triplets", print_triplets, 2);
+  rb_define_module_function(mPrimeSieve, "print_quadruplets", print_quadruplets, 2);
+  rb_define_module_function(mPrimeSieve, "print_quintuplets", print_quintuplets, 2);
+  rb_define_module_function(mPrimeSieve, "print_sextuplets", print_sextuplets, 2);
+  rb_define_module_function(mPrimeSieve, "callback_primes", callback_primes, 2);
+  rb_define_module_function(mPrimeSieve, "parallel_callback_primes", parallel_callback_primes, 2);
+  rb_define_module_function(mPrimeSieve, "get_sieve_size", get_sieve_size, 0);
+  rb_define_module_function(mPrimeSieve, "get_num_threads", get_num_threads, 0);
+  rb_define_module_function(mPrimeSieve, "get_max_stop", get_max_stop, 0);
+  rb_define_module_function(mPrimeSieve, "set_sieve_size", set_sieve_size, 1);
+  rb_define_module_function(mPrimeSieve, "set_num_threads", set_num_threads, 1);
+  rb_define_module_function(mPrimeSieve, "test", test, 0);
+}

data/ext/prime_sieve/prime_sieve.h

@@ -0,0 +1,9 @@
+#ifndef RUBY_PRIMESIEVE
+#define RUBY_PRIMESIEVE
+
+#include <ruby.h>
+#include <primesieve.h>
+
+extern VALUE mPrimesieve;
+
+#endif

data/lib/prime_sieve.rb

@@ -0,0 +1,5 @@
+require 'prime_sieve/prime_sieve'
+
+module PrimeSieve
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: prime_sieve
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Robert Looby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-21 00:00:00.000000000 Z
+dependencies: []
+description: A wrapper for the primesieve C prime number generator
+email: robertjlooby@gmail.com
+executables: []
+extensions:
+- ext/prime_sieve/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/prime_sieve/extconf.rb
+- ext/prime_sieve/prime_sieve.c
+- ext/prime_sieve/prime_sieve.h
+- lib/prime_sieve.rb
+homepage: https://github.com/robertjlooby/prime_sieve
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A wrapper for the primesieve lib
+test_files: []