ope-rb 0.0.1

data/ext/ope/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+dir_config('openssl')
+have_header("openssl/ssl.h")
+have_library("ssl", "SSLv23_method")
+create_makefile('ope/native')

data/ext/ope/native.c

@@ -0,0 +1,311 @@
+#include <ruby.h>
+#include <math.h>
+#include <openssl/rand.h>
+
+/*
+ *  Helper methods from Mathlib : A C Library of Special Functions
+ *  Copyright (C) 2005 The R Foundation, released under the GPL.
+ */
+static double afc(int i)
+{
+    static const double al[9] =
+    {
+	0.0,
+	0.0,/*ln(0!)=ln(1)*/
+	0.0,/*ln(1!)=ln(1)*/
+	0.69314718055994530941723212145817,/*ln(2) */
+	1.79175946922805500081247735838070,/*ln(6) */
+	3.17805383034794561964694160129705,/*ln(24)*/
+	4.78749174278204599424770093452324,
+	6.57925121201010099506017829290394,
+	8.52516136106541430016553103634712
+	/*, 10.60460290274525022841722740072165*/
+    };
+    double di, value;
+
+    if (i < 0) {
+      printf(("rhyper.c: afc(i), i=%d < 0 -- SHOULD NOT HAPPEN!\n"),
+		      i);
+      return -1;/* unreached (Wall) */
+    } else if (i <= 7) {
+	value = al[i + 1];
+    } else {
+	di = i;
+	value = (di + 0.5) * log(di) - di + 0.08333333333333 / di
+	    - 0.00277777777777 / di / di / di + 0.9189385332;
+    }
+    return value;
+}
+
+static int imax2(int x, int y) {
+  return (x < y) ? y : x;
+}
+
+static int imin2(int x, int y) {
+  return (x < y) ? x : y;
+}
+
+static VALUE ope_rb;
+static VALUE ope_rb_hgd;
+
+static VALUE ope_rb_rhyper(VALUE self, VALUE rbNn1in, VALUE rbNn2in, VALUE rbKkin, VALUE rbSeed) {
+  
+  double nn1in, nn2in, kkin;
+
+  static const double con = 57.56462733;
+  static const double deltal = 0.0078;
+  static const double deltau = 0.0034;
+  static const double scale = 1e25;
+  
+  int nn1, nn2, kk;
+  int i, ix;
+  int reject, setup1, setup2;
+
+  double e, f, g, p, r, t, u, v, y;
+  double de, dg, dr, ds, dt, gl, gu, nk, nm, ub;
+  double xk, xm, xn, y1, ym, yn, yk, alv;
+
+  static int ks = -1;
+  static int n1s = -1, n2s = -1;
+
+  static int k, m;
+  static int minjx, maxjx, n1, n2;
+
+  static double a, d, s, w;
+  static double tn, xl, xr, kl, kr, lamdl, lamdr, p1, p2, p3;
+  
+  unsigned char* seed;
+  int seedLen;
+  
+  nn1in = NUM2DBL(rbNn1in);
+  nn2in = NUM2DBL(rbNn2in);
+  kkin = NUM2DBL(rbKkin);
+  
+  StringValue(rbSeed);
+  seed = (unsigned char*) RSTRING_PTR(rbSeed);
+  seedLen = RSTRING_LEN(rbSeed);
+  RAND_seed(seed, seedLen);
+  
+  if(!isfinite(nn1in) || !isfinite(nn2in) || !isfinite(kkin))
+    return -1;
+
+  nn1 = (int) nn1in;
+  nn2 = (int) nn2in;
+  kk	= (int) kkin;
+
+  if (nn1 < 0 || nn2 < 0 || kk < 0 || kk > nn1 + nn2) {
+    //rb_raise(rb_eRuntimeError, 'Incorrect arguments to HGD');
+    return INT2NUM(-2);
+  }
+
+  reject = 1;
+  if (nn1 != n1s || nn2 != n2s) {
+  setup1 = 1;	setup2 = 1;
+  } else if (kk != ks) {
+  setup1 = 0;	setup2 = 1;
+  } else {
+  setup1 = 0;	setup2 = 0;
+  }
+  if (setup1) {
+  n1s = nn1;
+  n2s = nn2;
+  tn = nn1 + nn2;
+  if (nn1 <= nn2) {
+    n1 = nn1;
+    n2 = nn2;
+  } else {
+    n1 = nn2;
+    n2 = nn1;
+  }
+  }
+  if (setup2) {
+  ks = kk;
+  if (kk + kk >= tn) {
+    k = (int)(tn - kk);
+  } else {
+    k = kk;
+  }
+  }
+  if (setup1 || setup2) {
+  m = (int) ((k + 1.0) * (n1 + 1.0) / (tn + 2.0));
+  minjx = imax2(0, k - n2);
+  maxjx = imin2(n1, k);
+  }
+
+  if (minjx == maxjx) {
+  ix = maxjx;
+
+  if (kk + kk >= tn) {
+  if (nn1 > nn2) {
+    ix = kk - nn2 + ix;
+  } else {
+    ix = nn1 - ix;
+  }
+  } else {
+  if (nn1 > nn2)
+    ix = kk - ix;
+  }
+  
+  return DBL2NUM(ix);
+
+  } else if (m - minjx < 10) {
+  if (setup1 || setup2) {
+    if (k < n2) {
+  w = exp(con + afc(n2) + afc(n1 + n2 - k)
+  	- afc(n2 - k) - afc(n1 + n2));
+    } else {
+  w = exp(con + afc(n1) + afc(k)
+  	- afc(k - n2) - afc(n1 + n2));
+    }
+  }
+    L10:
+  p = w;
+  ix = minjx;
+  u = unif_rand(seed, seedLen) * scale;
+    L20:
+  if (u > p) {
+    u -= p;
+    p *= (n1 - ix) * (k - ix);
+    ix++;
+    p = p / ix / (n2 - k + ix);
+    if (ix > maxjx)
+  goto L10;
+    goto L20;
+  }
+  } else {
+
+  if (setup1 || setup2) {
+    s = sqrt((tn - k) * k * n1 * n2 / (tn - 1) / tn / tn);
+
+    d = (int) (1.5 * s) + .5;
+    xl = m - d + .5;
+    xr = m + d + .5;
+    a = afc(m) + afc(n1 - m) + afc(k - m) + afc(n2 - k + m);
+    kl = exp(a - afc((int) (xl)) - afc((int) (n1 - xl))
+       - afc((int) (k - xl))
+       - afc((int) (n2 - k + xl)));
+    kr = exp(a - afc((int) (xr - 1))
+       - afc((int) (n1 - xr + 1))
+       - afc((int) (k - xr + 1))
+       - afc((int) (n2 - k + xr - 1)));
+    lamdl = -log(xl * (n2 - k + xl) / (n1 - xl + 1) / (k - xl + 1));
+    lamdr = -log((n1 - xr + 1) * (k - xr + 1) / xr / (n2 - k + xr));
+    p1 = d + d;
+    p2 = p1 + kl / lamdl;
+    p3 = p2 + kr / lamdr;
+  }
+    L30:
+  u = unif_rand(seed, seedLen) * p3;
+  v = unif_rand(seed, seedLen);
+  if (u < p1) {
+    ix = (int) (xl + u);
+  } else if (u <= p2) {
+    ix = (int) (xl + log(v) / lamdl);
+    if (ix < minjx)
+  goto L30;
+    v = v * (u - p1) * lamdl;
+  } else {
+    ix = (int) (xr - log(v) / lamdr);
+    if (ix > maxjx)
+  goto L30;
+    v = v * (u - p2) * lamdr;
+  }
+
+  if (m < 100 || ix <= 50) {
+    f = 1.0;
+    if (m < ix) {
+  for (i = m + 1; i <= ix; i++)
+      f = f * (n1 - i + 1) * (k - i + 1) / (n2 - k + i) / i;
+    } else if (m > ix) {
+  for (i = ix + 1; i <= m; i++)
+      f = f * i * (n2 - k + i) / (n1 - i + 1) / (k - i + 1);
+    }
+    if (v <= f) {
+  reject = 0;
+    }
+  } else {
+    /* squeeze using upper and lower bounds */
+    y = ix;
+    y1 = y + 1.0;
+    ym = y - m;
+    yn = n1 - y + 1.0;
+    yk = k - y + 1.0;
+    nk = n2 - k + y1;
+    r = -ym / y1;
+    s = ym / yn;
+    t = ym / yk;
+    e = -ym / nk;
+    g = yn * yk / (y1 * nk) - 1.0;
+    dg = 1.0;
+    if (g < 0.0)
+  dg = 1.0 + g;
+    gu = g * (1.0 + g * (-0.5 + g / 3.0));
+    gl = gu - .25 * (g * g * g * g) / dg;
+    xm = m + 0.5;
+    xn = n1 - m + 0.5;
+    xk = k - m + 0.5;
+    nm = n2 - k + xm;
+    ub = y * gu - m * gl + deltau
+  + xm * r * (1. + r * (-0.5 + r / 3.0))
+  + xn * s * (1. + s * (-0.5 + s / 3.0))
+  + xk * t * (1. + t * (-0.5 + t / 3.0))
+  + nm * e * (1. + e * (-0.5 + e / 3.0));
+    alv = log(v);
+    if (alv > ub) {
+  reject = 1;
+    } else {
+  dr = xm * (r * r * r * r);
+  if (r < 0.0)
+      dr /= (1.0 + r);
+  ds = xn * (s * s * s * s);
+  if (s < 0.0)
+      ds /= (1.0 + s);
+  dt = xk * (t * t * t * t);
+  if (t < 0.0)
+      dt /= (1.0 + t);
+  de = nm * (e * e * e * e);
+  if (e < 0.0)
+      de /= (1.0 + e);
+  if (alv < ub - 0.25 * (dr + ds + dt + de)
+      + (y + m) * (gl - gu) - deltal) {
+      reject = 0;
+  }
+  else {
+      if (alv <= (a - afc(ix) - afc(n1 - ix)
+  		- afc(k - ix) - afc(n2 - k + ix))) {
+  	reject = 0;
+      } else {
+  	reject = 1;
+      }
+  }
+    }
+  }
+  if (reject)
+    goto L30;
+  }
+  
+  if (kk + kk >= tn) {
+    if (nn1 > nn2) {
+      ix = kk - nn2 + ix;
+    } else {
+      ix = nn1 - ix;
+    }
+  } else {
+  if (nn1 > nn2)
+    ix = kk - ix;
+  }
+  
+  return DBL2NUM(ix);
+  
+}
+
+void Init_native(void) {
+  
+	ope_rb = rb_define_module("OPE");
+	
+	ope_rb_hgd = rb_define_class_under(ope_rb, "HGD", rb_cObject);
+	rb_define_singleton_method(ope_rb_hgd, "rhyper_native", ope_rb_rhyper, 4);
+
+  return;
+	
+}

data/lib/ope-rb.rb

@@ -0,0 +1,155 @@
+require 'ope-rb/native'
+require 'ope-rb/version'
+require 'ope-rb/prng'
+require 'ope-rb/hgd'
+require 'ope-rb/crypto'
+require 'ope-rb/errors'
+
+module OPE
+  
+  class Cipher
+    
+    OPE_KEY_SIZE = 128
+    
+    include Crypto
+    
+    def initialize(key, pt_len = 8, ct_len = 16)
+      
+      check_key_size(key)
+        
+      @key, @pt_len, @ct_len =
+      key, pt_len * 8, ct_len * 8
+      
+      create_cipher
+      
+    end
+    
+    def check_key_size(key)
+      
+      valid = key.bytesize * 8 == OPE_KEY_SIZE
+      raise Errors::KeySizeError unless valid
+      
+    end
+    
+    def sample_hgd(lo_d, hi_d, lo_r, hi_r, y, coins)
+      
+      wb, bp = hi_d - lo_d + 1, y - lo_r
+      bb = hi_r - lo_r + 1 - wb
+      
+      unless wb > 0 && bb >= 0 && y >= lo_r && y <= hi_r
+        raise Errors::HGDParameterError
+      end
+      
+      prec = (hi_r - lo_r + 1).size * 8 + 10
+
+      lo_d + HGD.rhyper(bp, wb, bb, coins, prec)
+      
+    end
+    
+    def tape_gen(lo_d, hi_d, y, desired_no_bits)
+      
+      if desired_no_bits % 8 != 0
+        raise Errors::NumBitsError
+      elsif (desired_bytes = desired_no_bits / 8) > 16
+        raise Errors::DesiredBytesError
+      end
+      
+      digest = hash_concat(lo_d, hi_d, y)
+      seed = get_seed(digest, desired_bytes)
+      
+    end
+    
+    def encrypt(m)
+      
+      lo_d, hi_d = 0, (1 << @pt_len) - 1
+      lo_r, hi_r = 0, (1 << @ct_len) - 1
+      
+      encrypt_recurse(lo_d, hi_d, lo_r, hi_r, m)
+      
+    end
+    
+    def decrypt(m)
+
+      lo_d, hi_d = 0, (1 << @pt_len) - 1
+      lo_r, hi_r = 0, (1 << @ct_len) - 1
+
+      decrypt_recurse(lo_d, hi_d, lo_r, hi_r, m)
+      
+    end
+    
+    private
+    
+    def get_seed(digest, desired_bytes)
+      
+      # Encrypt the hash using the cipher
+      seed = cipher_encrypt(digest)
+      
+      # Take only the desired no of bytes
+      seed = seed.byteslice(0, desired_bytes)
+   
+      # Convert the seed to a Bignum
+      seed.unpack('H*')[0].hex
+      
+    end
+    
+    def encrypt_recurse(lo_d, hi_d, lo_r, hi_r, m)
+      
+      m2, n = hi_d - lo_d + 1, hi_r - lo_r + 1
+      d, r = lo_d - 1, lo_r - 1; y = r + (n + 1) / 2
+      
+      raise Errors::IncorrectMValueError unless m2 > 0
+
+      coins = nil
+      
+      if m2 == 1
+        
+        coins = tape_gen(lo_d, hi_d, m, @ct_len)
+        return lo_r + (coins % n)
+        
+      end
+      
+      coins = tape_gen(lo_d, hi_d, y, @pt_len)
+      
+      x = sample_hgd(lo_d, hi_d, lo_r, hi_r, y, coins)
+      
+      lo_d, hi_d = *((m <= x) ? [d + 1, x] : [x + 1, d + m2])
+      lo_r, hi_r = *((m <= x) ? [r + 1, y] : [y + 1, r + n])
+      
+      encrypt_recurse(lo_d, hi_d, lo_r, hi_r, m)
+      
+    end
+    
+    def decrypt_recurse(lo_d, hi_d, lo_r, hi_r, c)
+      
+      m2, n = hi_d - lo_d + 1, hi_r - lo_r + 1
+      d, r = lo_d - 1, lo_r - 1; y = r + (n + 1) / 2
+      
+      raise Errors::IncorrectMValueError unless m2 > 0
+      
+      if m2 == 1
+
+        m = lo_d.to_i
+        
+        coins = tape_gen(lo_d, hi_d, m, @ct_len)
+        w = lo_r + coins % n
+        
+        return m.to_i if w == c
+        
+        raise Errors::BadDecryptError
+        
+      end
+      
+      coins = tape_gen(lo_d, hi_d, y, @pt_len)
+      
+      x = sample_hgd(lo_d, hi_d, lo_r, hi_r, y, coins)
+      
+      lo_d, hi_d = *((c <= y) ? [d + 1, x] : [x + 1, d + m2])
+      lo_r, hi_r = *((c <= y) ? [r + 1, y] : [y + 1, r + n])
+
+      decrypt_recurse(lo_d, hi_d, lo_r, hi_r, c)
+      
+    end
+    
+  end
+  
+end

data/lib/ope-rb/crypto.rb

@@ -0,0 +1,33 @@
+module OPE
+  
+  module Crypto
+
+    def hash_concat(*args)
+      
+      lens = args.map { |arg| [1].pack("L") }
+      hash((lens + args).join(''))
+      
+    end
+    
+    def hash(data)
+      
+      OpenSSL::Digest::SHA256.digest(data)
+      
+    end
+    
+    def create_cipher
+      
+      @cipher = OpenSSL::Cipher::AES.new(128, :ECB)
+      @cipher.encrypt; @cipher.key = @key
+      
+    end
+    
+    def cipher_encrypt(data)
+      
+      @cipher.update(data) + @cipher.final
+      
+    end
+  
+  end
+  
+end

data/lib/ope-rb/errors.rb

@@ -0,0 +1,55 @@
+module OPE
+  
+  module Errors
+    
+    class KeySizeError < StandardError
+    
+      def initialize
+        super('Incorrect key size')
+      end
+    
+    end
+  
+    class HGDParameterError < StandardError
+    
+      def initialize
+        super('Corrupt HGD parameters')
+      end
+    
+    end
+  
+    class NumBitsError < StandardError
+    
+      def initialize
+        super('Desired no bits not a multiple of 8')
+      end
+    
+    end
+  
+    class DesiredBytesError < StandardError
+    
+      def initialize
+        super('Only 64-bit output is supported for now')
+      end
+    
+    end
+  
+    class IncorrectMValueError < StandardError
+    
+      def initialize
+        super('M should not be less than or equal to 0')
+      end
+    
+    end
+    
+    class BadDecryptError < StandardError
+    
+      def initialize
+        super('Decryption failed')
+      end
+    
+    end
+    
+  end
+  
+end

data/lib/ope-rb/hgd.rb

@@ -0,0 +1,267 @@
+module OPE
+  
+  class HGD
+    
+    # Random variates from the hypergeometric distribution.
+    #
+    # Returns the number of white balls drawn when kk balls
+    # are drawn at random from an urn containing nn1 white
+    # and nn2 black balls.
+    def self.rhyper(kk, nn1, nn2, coins, precision)
+
+      ix = nil
+      
+      prng = PRNG.new(coins)
+      
+      con, deltal = 57.56462733, 0.0078
+      deltau, scale = 0.0034, 1.0e25
+      
+      # Check validity of parameters.
+      if [nn1, nn2, kk].include?(Float::INFINITY) ||
+         (nn1 < 0 || nn2 < 0 || kk < 0 || kk > (nn1 + nn2))
+        raise 'Invalid parameters nn1, nn2 or kk'
+      end 
+      
+      reject = true
+      
+      if nn1 >= nn2
+        n1, n2 = nn2.to_f, nn1.to_f
+      else
+        n1, n2 = nn1.to_f, nn2.to_f
+      end
+      
+      tn = n1 + n2
+      
+      if kk + kk >= tn
+        k = tn - kk
+      else
+        k = kk
+      end
+      
+      m = (k+1.0) * (n1+1.0) / (tn+2.0)
+      
+      minjx = (k - n2 < 0) ? 0 : k - n2
+      maxjx = (n1 < k) ? n1 : k
+      
+      # Degenerate distribution
+      if minjx == maxjx
+    
+        # no, need to untangle TSL
+        return maxjx.floor.to_f
+      
+      # Inverse transformation
+      elsif m-minjx < 10
+        
+        w = nil
+        
+        if k < n2
+          w = Math.exp(con + afc(n2) + afc(n1+n2-k)-afc(n2-k)-afc(n1+n2))
+        else
+          w = Math.exp(con + afc(n1) + afc(k) + afc(k-n2) -afc(n1+n2))
+        end
+        
+        catch :l10 do
+          
+          p = w
+          ix = minjx
+          u = prng.draw * scale
+          
+          catch :l20 do
+            
+            if u > p
+              u = u - p
+              p = p * (n1-ix)*(k-ix)
+              ix = ix + 1
+              p = p / ix / (n2-k+ix)
+              throw :l10 if ix > maxjx
+              throw :l20
+            end
+            
+          end
+          
+        end
+        
+      # Hypergeometrics-2 points-exponential tails
+      else
+        
+        s = Math.sqrt( (tn-k) * k * n1 * n2 / (tn - 1.0) / tn / tn)
+        
+        # Truncation centers cell boundaries at 0.5
+        d = (1.5 * s).floor.to_f + 0.5
+        xl = m - d + 0.5
+        xr = m + d + 0.5
+        a = afc(m) + afc(n1-m) +
+          afc(k-m) + afc(n2-k+m) 
+        
+        expon = a - afc(xl) -
+          afc(n1 - xl) - afc(k - xl) -
+          afc(n2 - k + xl)
+        
+        kl = Math.exp(expon)
+        
+        kr = Math.exp(a - afc(xr-1) -
+          afc(n1-xr+1) - afc(k-xr+1) -
+          afc(n2-k+xr-1))
+        
+        lamdl = -Math.log(xl *
+          (n2 - k + xl) / (n1 - xl + 1) / (k - xl + 1))
+          
+        lamdr = -Math.log(
+          (n1 - xr + 1) * (k -xr + 1) / xr / (n2 - k + xr))
+        
+        p1 = 2 * d
+        p2 = p1 + kl / lamdl
+        p3 = p2 + kr / lamdr
+        
+        count_30 = 0
+        
+        catch :count do
+          
+          count_30 += 1
+
+          u = prng.draw * p3
+          v = prng.draw
+
+          # Rectangular region
+          if u < p1
+            ix = xl + u
+          # Left tail region
+          elsif u <= p2
+            ix = xl + Math.log(v) / lamdl
+            throw :count if ix < minjx
+            v = v * (u - p1) * lamdl
+          # Right tail region
+          else
+            ix = xr - Math.log(v) / lamdr
+            throw :count if ix > maxjx
+            v = v * (u - p2) * lamdr
+          end
+          
+          f = nil
+          
+          if m < 100 || ix <= 50
+            
+            f = 1
+            
+            if m < ix
+              
+              i = m + 1
+              
+              while i < ix # <= ?
+                
+                f = f * (n1 - i + 1.0) *
+                        (k - i + 1.0) /
+                        (n2 - k + i) / i
+                i += 1
+                
+              end
+              
+            elsif m > ix
+              
+              i = ix + 1
+              
+              while i < m # <= ?
+                
+                f = f * i * (n2 - k + i) /
+                    (n1 - i) / (k - i) # + 1 ?
+                i += 1
+                
+              end
+              
+            end
+            
+            reject = false if v <= f
+            
+          else
+            
+            y = ix; y1 = y + 1.0; ym = y - m
+            yn = n1 - y + 1.0; yk = k - y + 1.0
+            nk = n2 - k + y1; r = -ym / y1
+            s2 = ym / yn; t = ym / yk; e = -ym / nk
+            g = yn * yk / (y1 * nk) - 1.0
+            dg = 1.0; dg = 1.0 + g if g < 0
+            gu = g * (1.0 + g * (-0.5 + g / 3.0))
+            gl = gu - 0.25 * (g * g * g * g) / dg
+            xm = m + 0.5; xn = n1 - m + 0.5
+            xk = k - m + 0.5; nm = n2 - k + xm
+            
+            ub = y * gu - m * gl + deltau + xm *
+                 r * (1 + r * (-0.5 + r / 3)) +
+                 xn * s2 * (1.0 + s2 * (-0.5 + s2 / 3.0)) +
+                 xk * t * (1.0 + t * (-0.5 + t / 3.0)) +
+                 nm * e * (1.0 + e * (-0.5 + e / 3.0))
+            
+            alv = Math.log(v)
+            
+            if alv > ub
+              reject = true
+            else
+              
+              dr = xm * (r * r * r * r)
+              dr /= (1.0 + r) if r < 0
+              ds = xn * (s2 * s2 * s2 * s2)
+              ds /= (1.0 + s2) if s2 < 0
+              dt = xk * (t * t * t * t)
+              dt /= (1.0 + t) if t < 0
+              de = nm * (e * e * e * e)
+              de /= (1.0 + e) if e < 0
+              
+              
+              cand = ub - 0.25 * (dr + ds + dt + de) +
+              (y + m) * (gl - gu) - deltal
+            
+              if alv < cand
+                reject = false
+              else  
+              
+            
+              cand = a - afc(ix) - afc(n1 - ix) -
+              afc(k - ix) - afc(n2 - k + ix)
+              
+              reject = alv > cand
+            
+            end
+          
+          end
+          
+        end
+        
+        throw :count if reject
+        
+      end
+        
+      end
+      
+      if kk + kk >= tn
+        if nn1 > nn2
+          ix = kk - nn2 + ix
+        else
+          ix = nn1 - ix
+        end
+      else
+        ix = kk - ix if nn1 > nn2
+      end
+      
+      jx = ix
+      
+      return jx.floor.to_f
+      
+    end
+    
+    # Calculates logarithm of i factorial: ln(i!)
+    # Uses Stirling's approximation to do so.
+    def self.afc(i)
+      
+      raise 'i should not be < 0' if i < 0
+      
+      frac_12, frac_360 = 1.0 / 12.0, 1.0 / 360.0
+      frac_pi = 0.5 * Math.log(2 * Math::PI)
+      
+      (i + 0.5) * Math.log(i) - i + frac_12 /
+      i - frac_360 / i / i / i + frac_pi
+      
+    end
+  
+  end
+  
+end

data/lib/ope-rb/prng.rb

@@ -0,0 +1,21 @@
+module OPE
+  
+  class PRNG
+  
+    require 'bigdecimal'
+    require 'drbg-rb'
+    
+    def initialize(coin)
+      coin = coin.to_s
+      coin += '0' while coin.bytesize < 24
+      @prng = DRBG::HMAC.new(coin, 128)
+    end
+    
+    def draw
+      n = @prng.generate(4, 128).unpack('H*')[0]
+      n.byteslice(0, 8).hex.to_f / 2**32
+    end
+    
+  end
+  
+end

data/lib/ope-rb/version.rb

@@ -0,0 +1,5 @@
+module OPE
+  
+  VERSION = '0.0.1'
+  
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: ope-rb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Louis Mullie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! '  '
+email:
+- louis.mullie@gmail.com
+executables: []
+extensions:
+- ext/ope/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/ope-rb/crypto.rb
+- lib/ope-rb/errors.rb
+- lib/ope-rb/hgd.rb
+- lib/ope-rb/prng.rb
+- lib/ope-rb/version.rb
+- lib/ope-rb.rb
+- ext/ope/native.c
+- ext/ope/extconf.rb
+homepage: https://github.com/cryodex/ope-rb
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: A Ruby implementation of order-preserving encryption
+test_files: []