primesieve 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e9031aa8943664d27211a80ce6292c2c10a98037
+  data.tar.gz: b072982a8ea70aa8be378dc17387eeb9345f351d
+SHA512:
+  metadata.gz: d04e858b99d6212829d9aa345c2defc5505279bc305815c505e8426ede15252c03700b4f36d16a9299cf6a4b53d3cc7448116da1e0d7af9dfbf516002d38b7d6
+  data.tar.gz: eff00f0a834bf3baf7bad1d0335f062b13b029ee155773977a84014a013c91ecb3cbb0486ecdcc5c892c6a2c8c027e90bda2105e17416f8b52326057c52614a6

data/ext/primesieve/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("primesieve/primesieve")

data/ext/primesieve/primesieve-ruby.c

@@ -0,0 +1,196 @@
+#include <primesieve-ruby.h>
+
+VALUE mPrimesieve;
+
+static VALUE generate_primes(VALUE self, VALUE start, VALUE stop) {
+  size_t size, i;
+  uint64_t* primes = (uint64_t *) primesieve_generate_primes(NUM2ULL(start), NUM2ULL(stop), &size, UINT64_PRIMES);
+  VALUE ruby_primes = rb_ary_new2(size);
+  for(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) {
+  long i;
+  uint64_t* primes = (uint64_t *) primesieve_generate_n_primes(NUM2ULL(n), NUM2ULL(start), UINT64_PRIMES);
+  VALUE ruby_primes = rb_ary_new2(NUM2LONG(n));
+  for(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_primesieve() {
+  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/primesieve/primesieve-ruby.h

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

data/lib/primesieve.rb

@@ -0,0 +1,5 @@
+require 'primesieve/primesieve'
+
+module Primesieve
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: primesieve
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Robert Looby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-14 00:00:00.000000000 Z
+dependencies: []
+description: A wrapper for the primesieve C prime number generator
+email: robertjlooby@gmail.com
+executables: []
+extensions:
+- ext/primesieve/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/primesieve/extconf.rb
+- ext/primesieve/primesieve-ruby.c
+- ext/primesieve/primesieve-ruby.h
+- lib/primesieve.rb
+homepage: https://github.com/robertjlooby/primesieve-ruby
+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.4.4
+signing_key: 
+specification_version: 4
+summary: A wrapper for the primesieve lib
+test_files: []