Module: PrimeSieve

Defined in:
lib/prime_sieve.rb,
ext/prime_sieve/prime_sieve.c

Constant Summary collapse

VERSION = 
'0.0.3'

Class Method Summary collapse

Class Method Details

.callback_primes(start, stop) ⇒ Object 



118
119
120
121
122
123
 
# File 'ext/prime_sieve/prime_sieve.c', line 118

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;
}

.count_primes(start, stop) ⇒ Object 



35
36
37
 
# File 'ext/prime_sieve/prime_sieve.c', line 35

static VALUE count_primes(VALUE self, VALUE start, VALUE stop) {
  return ULL2NUM(primesieve_count_primes(NUM2ULL(start), NUM2ULL(stop)));
}

.count_quadruplets(start, stop) ⇒ Object 



47
48
49
 
# File 'ext/prime_sieve/prime_sieve.c', line 47

static VALUE count_quadruplets(VALUE self, VALUE start, VALUE stop) {
  return ULL2NUM(primesieve_count_quadruplets(NUM2ULL(start), NUM2ULL(stop)));
}

.count_quintuplets(start, stop) ⇒ Object 



51
52
53
 
# File 'ext/prime_sieve/prime_sieve.c', line 51

static VALUE count_quintuplets(VALUE self, VALUE start, VALUE stop) {
  return ULL2NUM(primesieve_count_quintuplets(NUM2ULL(start), NUM2ULL(stop)));
}

.count_sextuplets(start, stop) ⇒ Object 



55
56
57
 
# File 'ext/prime_sieve/prime_sieve.c', line 55

static VALUE count_sextuplets(VALUE self, VALUE start, VALUE stop) {
  return ULL2NUM(primesieve_count_sextuplets(NUM2ULL(start), NUM2ULL(stop)));
}

.count_triplets(start, stop) ⇒ Object 



43
44
45
 
# File 'ext/prime_sieve/prime_sieve.c', line 43

static VALUE count_triplets(VALUE self, VALUE start, VALUE stop) {
  return ULL2NUM(primesieve_count_triplets(NUM2ULL(start), NUM2ULL(stop)));
}

.count_twins(start, stop) ⇒ Object 



39
40
41
 
# File 'ext/prime_sieve/prime_sieve.c', line 39

static VALUE count_twins(VALUE self, VALUE start, VALUE stop) {
  return ULL2NUM(primesieve_count_twins(NUM2ULL(start), NUM2ULL(stop)));
}

.generate_n_primes(n, start) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
 
# File 'ext/prime_sieve/prime_sieve.c', line 16

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;
}

.generate_primes(start, stop) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
 
# File 'ext/prime_sieve/prime_sieve.c', line 5

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;
}

.get_max_stop ⇒ Object 



145
146
147
 
# File 'ext/prime_sieve/prime_sieve.c', line 145

static VALUE get_max_stop(VALUE self) {
  return ULL2NUM(primesieve_get_max_stop());
}

.get_num_threads ⇒ Object 



141
142
143
 
# File 'ext/prime_sieve/prime_sieve.c', line 141

static VALUE get_num_threads(VALUE self) {
  return INT2NUM(primesieve_get_num_threads());
}

.get_sieve_size ⇒ Object 



137
138
139
 
# File 'ext/prime_sieve/prime_sieve.c', line 137

static VALUE get_sieve_size(VALUE self) {
  return INT2NUM(primesieve_get_sieve_size());
}

.nth_prime(n, start) ⇒ Object 



27
28
29
 
# File 'ext/prime_sieve/prime_sieve.c', line 27

static VALUE nth_prime(VALUE self, VALUE n, VALUE start) {
  return ULL2NUM(primesieve_nth_prime(NUM2LL(n), NUM2ULL(start)));
}

.parallel_callback_primes(start, stop) ⇒ Object 



130
131
132
133
134
135
 
# File 'ext/prime_sieve/prime_sieve.c', line 130

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;
}

.parallel_count_primes(start, stop) ⇒ Object 



59
60
61
 
# File 'ext/prime_sieve/prime_sieve.c', line 59

static VALUE parallel_count_primes(VALUE self, VALUE start, VALUE stop) {
  return ULL2NUM(primesieve_parallel_count_primes(NUM2ULL(start), NUM2ULL(stop)));
}

.parallel_count_quadruplets(start, stop) ⇒ Object 



71
72
73
 
# File 'ext/prime_sieve/prime_sieve.c', line 71

static VALUE parallel_count_quadruplets(VALUE self, VALUE start, VALUE stop) {
  return ULL2NUM(primesieve_parallel_count_quadruplets(NUM2ULL(start), NUM2ULL(stop)));
}

.parallel_count_quintuplets(start, stop) ⇒ Object 



75
76
77
 
# File 'ext/prime_sieve/prime_sieve.c', line 75

static VALUE parallel_count_quintuplets(VALUE self, VALUE start, VALUE stop) {
  return ULL2NUM(primesieve_parallel_count_quintuplets(NUM2ULL(start), NUM2ULL(stop)));
}

.parallel_count_sextuplets(start, stop) ⇒ Object 



79
80
81
 
# File 'ext/prime_sieve/prime_sieve.c', line 79

static VALUE parallel_count_sextuplets(VALUE self, VALUE start, VALUE stop) {
  return ULL2NUM(primesieve_parallel_count_sextuplets(NUM2ULL(start), NUM2ULL(stop)));
}

.parallel_count_triplets(start, stop) ⇒ Object 



67
68
69
 
# File 'ext/prime_sieve/prime_sieve.c', line 67

static VALUE parallel_count_triplets(VALUE self, VALUE start, VALUE stop) {
  return ULL2NUM(primesieve_parallel_count_triplets(NUM2ULL(start), NUM2ULL(stop)));
}

.parallel_count_twins(start, stop) ⇒ Object 



63
64
65
 
# File 'ext/prime_sieve/prime_sieve.c', line 63

static VALUE parallel_count_twins(VALUE self, VALUE start, VALUE stop) {
  return ULL2NUM(primesieve_parallel_count_twins(NUM2ULL(start), NUM2ULL(stop)));
}

.parallel_nth_prime(n, start) ⇒ Object 



31
32
33
 
# File 'ext/prime_sieve/prime_sieve.c', line 31

static VALUE parallel_nth_prime(VALUE self, VALUE n, VALUE start) {
  return ULL2NUM(primesieve_parallel_nth_prime(NUM2LL(n), NUM2ULL(start)));
}

.print_primes(start, stop) ⇒ Object 



83
84
85
86
 
# File 'ext/prime_sieve/prime_sieve.c', line 83

static VALUE print_primes(VALUE self, VALUE start, VALUE stop) {
  primesieve_print_primes(NUM2ULL(start), NUM2ULL(stop));
  return Qnil;
}

.print_quadruplets(start, stop) ⇒ Object 



98
99
100
101
 
# File 'ext/prime_sieve/prime_sieve.c', line 98

static VALUE print_quadruplets(VALUE self, VALUE start, VALUE stop) {
  primesieve_print_quadruplets(NUM2ULL(start), NUM2ULL(stop));
  return Qnil;
}

.print_quintuplets(start, stop) ⇒ Object 



103
104
105
106
 
# File 'ext/prime_sieve/prime_sieve.c', line 103

static VALUE print_quintuplets(VALUE self, VALUE start, VALUE stop) {
  primesieve_print_quintuplets(NUM2ULL(start), NUM2ULL(stop));
  return Qnil;
}

.print_sextuplets(start, stop) ⇒ Object 



108
109
110
111
 
# File 'ext/prime_sieve/prime_sieve.c', line 108

static VALUE print_sextuplets(VALUE self, VALUE start, VALUE stop) {
  primesieve_print_sextuplets(NUM2ULL(start), NUM2ULL(stop));
  return Qnil;
}

.print_triplets(start, stop) ⇒ Object 



93
94
95
96
 
# File 'ext/prime_sieve/prime_sieve.c', line 93

static VALUE print_triplets(VALUE self, VALUE start, VALUE stop) {
  primesieve_print_triplets(NUM2ULL(start), NUM2ULL(stop));
  return Qnil;
}

.print_twins(start, stop) ⇒ Object 



88
89
90
91
 
# File 'ext/prime_sieve/prime_sieve.c', line 88

static VALUE print_twins(VALUE self, VALUE start, VALUE stop) {
  primesieve_print_twins(NUM2ULL(start), NUM2ULL(stop));
  return Qnil;
}

.set_num_threads(num_threads) ⇒ Object 



154
155
156
157
 
# File 'ext/prime_sieve/prime_sieve.c', line 154

static VALUE set_num_threads(VALUE self, VALUE num_threads) {
  primesieve_set_num_threads(NUM2INT(num_threads));
  return Qnil;
}

.set_sieve_size(sieve_size) ⇒ Object 



149
150
151
152
 
# File 'ext/prime_sieve/prime_sieve.c', line 149

static VALUE set_sieve_size(VALUE self, VALUE sieve_size) {
  primesieve_set_sieve_size(NUM2INT(sieve_size));
  return Qnil;
}

.test ⇒ Object 



159
160
161
 
# File 'ext/prime_sieve/prime_sieve.c', line 159

static VALUE test(VALUE self) {
  return INT2NUM(primesieve_test());
}