tuplex 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b58ffe6b6580580163d4fe58df687ad5ea20e6de
+  data.tar.gz: 5289b5307ea0788d2ad79ba50f8ee9b957f5b714
+SHA512:
+  metadata.gz: 652c10a64977a7b1a61b908b438615e47bd6f74c7db78e141bb6cb84552d51357dfb0078080cd8146fbbb048a95f7ff3ccbe6125d8f96761df2df4a9c550ff6d
+  data.tar.gz: 7edc4d53d20e441c2feb42957e46e91de37e30aea649024743e59385e4b64df3723f1211c98a7e4b423d41aa73c9335401d72ad2727a5be4be293395ab799a40

data/COPYING

@@ -0,0 +1,22 @@
+Copyright (c) 2013-2014, Joel VanderWerf
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,16 @@
+Tuplex
+==
+
+Constructs index keys for tuples.
+
+Contact
+=======
+
+Joel VanderWerf, vjoel@users.sourceforge.net, [@JoelVanderWerf](https://twitter.com/JoelVanderWerf).
+
+License and Copyright
+========
+
+Copyright (c) 2014, Joel VanderWerf
+
+License for this project is BSD. See the COPYING file for the standard BSD license. The supporting gems developed for this project are similarly licensed.

data/ext/isaac/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile 'isaac'

data/ext/isaac/isaac.c

@@ -0,0 +1,247 @@
+#include "ruby.h"
+#include "rand.h"
+#include "rand4.h"
+
+#ifndef min
+# define min(a,b) (((a)<(b)) ? (a) : (b))
+#endif /* min */
+
+static VALUE
+ISAAC_s_allocate(VALUE klass)
+{
+    randctx *ctx;
+
+    return Data_Make_Struct(klass, randctx, NULL, NULL, ctx);
+}
+
+static VALUE
+ISAAC4_s_allocate(VALUE klass)
+{
+    randctx4 *ctx;
+
+    return Data_Make_Struct(klass, randctx4, NULL, NULL, ctx);
+}
+
+/*
+ * Seed the generator with an array of up to ISAAC::RANDSIZ integers in the
+ * range 0..2**32-1. More entries are ignored. Missing entries are treated
+ * as 0. Returns +nil+.
+ */
+static VALUE
+ISAAC_srand(VALUE self, VALUE ary)
+{
+    int i;
+    randctx *ctx;
+
+    Check_Type(ary, T_ARRAY);
+    
+    Data_Get_Struct(self, randctx, ctx);
+    
+    MEMZERO(ctx, randctx, 1);
+    for (i=min(RANDSIZ, RARRAY_LEN(ary))-1; i>=0; i--) {
+        ctx->randrsl[i] = NUM2UINT(RARRAY_PTR(ary)[i]);
+    }
+    isaac_init(ctx, 1);
+
+    return Qnil;
+}
+
+/*
+ * Seed the generator with an array of up to ISAAC::RANDSIZ integers in the
+ * range 0..2**32-1. More entries are ignored. Missing entries are treated
+ * as 0. Returns +nil+.
+ */
+static VALUE
+ISAAC4_srand(VALUE self, VALUE ary)
+{
+    int i;
+    randctx4 *ctx;
+
+    Check_Type(ary, T_ARRAY);
+    
+    Data_Get_Struct(self, randctx4, ctx);
+    
+    MEMZERO(ctx, randctx4, 1);
+    for (i=min(RANDSIZ4, RARRAY_LEN(ary))-1; i>=0; i--) {
+        ctx->randrsl[i] = NUM2UINT(RARRAY_PTR(ary)[i]);
+    }
+    isaac_init4(ctx, 1);
+
+    return Qnil;
+}
+
+/*
+ * Return a random integer in the range 0..2**32-1.
+ */
+static VALUE
+ISAAC_rand32(VALUE self)
+{
+    randctx *ctx;
+
+    Data_Get_Struct(self, randctx, ctx);
+
+    if (!ctx->randcnt--) {
+        isaac_rand(ctx);
+        ctx->randcnt=RANDSIZ-1;
+    }
+    
+    return UINT2NUM(ctx->randrsl[ctx->randcnt]);
+}
+
+/*
+ * Return a random integer in the range 0..2**32-1.
+ */
+static VALUE
+ISAAC4_rand32(VALUE self)
+{
+    randctx4 *ctx;
+
+    Data_Get_Struct(self, randctx4, ctx);
+
+    if (!ctx->randcnt--) {
+        isaac_rand4(ctx);
+        ctx->randcnt=RANDSIZ4-1;
+    }
+    
+    return UINT2NUM(ctx->randrsl[ctx->randcnt]);
+}
+
+/*
+ * Return a random float in the range 0..1.
+ */
+static VALUE
+ISAAC_rand(VALUE self)
+{
+    randctx *ctx;
+
+    Data_Get_Struct(self, randctx, ctx);
+
+    if (!ctx->randcnt--) {
+        isaac_rand(ctx);
+        ctx->randcnt=RANDSIZ-1;
+    }
+    
+    return rb_float_new(ctx->randrsl[ctx->randcnt] / 4294967295.0);
+}
+
+/*
+ * Return a random float in the range 0..1.
+ */
+static VALUE
+ISAAC4_rand(VALUE self)
+{
+    randctx4 *ctx;
+
+    Data_Get_Struct(self, randctx4, ctx);
+
+    if (!ctx->randcnt--) {
+        isaac_rand4(ctx);
+        ctx->randcnt=RANDSIZ4-1;
+    }
+    
+    return rb_float_new(ctx->randrsl[ctx->randcnt] / 4294967295.0);
+}
+
+static VALUE
+ISAAC_marshal_dump(VALUE self)
+{
+    randctx *ctx;
+    int i;
+    int ary_size = sizeof(randctx)/sizeof(ub4);
+    VALUE ary;
+
+    Data_Get_Struct(self, randctx, ctx);
+    
+    ary = rb_ary_new2(ary_size);
+    for (i = 0; i < ary_size; i++) {
+        rb_ary_push(ary, UINT2NUM(((ub4 *)ctx)[i]));
+    }
+    
+    return ary;
+}
+
+static VALUE
+ISAAC4_marshal_dump(VALUE self)
+{
+    randctx4 *ctx;
+    int i;
+    int ary_size = sizeof(randctx4)/sizeof(ub4);
+    VALUE ary;
+
+    Data_Get_Struct(self, randctx4, ctx);
+    
+    ary = rb_ary_new2(ary_size);
+    for (i = 0; i < ary_size; i++) {
+        rb_ary_push(ary, UINT2NUM(((ub4 *)ctx)[i]));
+    }
+    
+    return ary;
+}
+
+static VALUE
+ISAAC_marshal_load(VALUE self, VALUE ary)
+{
+    randctx *ctx;
+    int i;
+    int ary_size = sizeof(randctx)/sizeof(ub4);
+
+    Data_Get_Struct(self, randctx, ctx);
+
+    if (RARRAY_LEN(ary) != ary_size)
+        rb_raise(rb_eArgError, "bad length in loaded ISAAC data");
+
+    for (i = 0; i < ary_size; i++) {
+        ((ub4 *)ctx)[i] = NUM2UINT(RARRAY_PTR(ary)[i]);
+    }
+    
+    return self;
+}
+
+static VALUE
+ISAAC4_marshal_load(VALUE self, VALUE ary)
+{
+    randctx4 *ctx;
+    int i;
+    int ary_size = sizeof(randctx4)/sizeof(ub4);
+
+    Data_Get_Struct(self, randctx4, ctx);
+
+    if (RARRAY_LEN(ary) != ary_size)
+        rb_raise(rb_eArgError, "bad length in loaded ISAAC4 data");
+
+    for (i = 0; i < ary_size; i++) {
+        ((ub4 *)ctx)[i] = NUM2UINT(RARRAY_PTR(ary)[i]);
+    }
+    
+    return self;
+}
+
+void
+Init_isaac()
+{
+    VALUE ISAAC;
+    VALUE ISAAC4;
+    VALUE mPRNG;
+
+    mPRNG = rb_define_module("PRNG");
+    ISAAC = rb_define_class_under(mPRNG, "ISAAC", rb_cObject);
+    ISAAC4 = rb_define_class_under(mPRNG, "ISAAC4", rb_cObject);
+    rb_define_const(ISAAC, "VERSION", rb_str_new_cstr("0.1.2"));
+        
+    rb_define_alloc_func(ISAAC, ISAAC_s_allocate);
+    rb_define_method(ISAAC, "srand", ISAAC_srand, 1);
+    rb_define_method(ISAAC, "rand32", ISAAC_rand32, 0);
+    rb_define_method(ISAAC, "rand", ISAAC_rand, 0);
+    rb_define_method(ISAAC, "marshal_dump", ISAAC_marshal_dump, 0);
+    rb_define_method(ISAAC, "marshal_load", ISAAC_marshal_load, 1);
+    
+    rb_define_alloc_func(ISAAC4, ISAAC4_s_allocate);
+    rb_define_method(ISAAC4, "srand", ISAAC4_srand, 1);
+    rb_define_method(ISAAC4, "rand32", ISAAC4_rand32, 0);
+    rb_define_method(ISAAC4, "rand", ISAAC4_rand, 0);
+    rb_define_method(ISAAC4, "marshal_dump", ISAAC4_marshal_dump, 0);
+    rb_define_method(ISAAC4, "marshal_load", ISAAC4_marshal_load, 1);
+    
+    rb_const_set(ISAAC, rb_intern("RANDSIZ"), UINT2NUM(RANDSIZ));
+    rb_const_set(ISAAC4, rb_intern("RANDSIZ"), UINT2NUM(RANDSIZ4));
+}

data/ext/isaac/rand.c

@@ -0,0 +1,139 @@
+/*
+------------------------------------------------------------------------------
+rand.c: By Bob Jenkins.  My random number generator, ISAAC.  Public Domain.
+MODIFIED:
+  960327: Creation (addition of randinit, really)
+  970719: use context, not global variables, for internal state
+  980324: added main (ifdef'ed out), also rearranged randinit()
+  010626: Note that this is public domain
+  
+ADAPTED Aug2004 for use in Ruby by Joel VanderWerf
+ADAPTED Jan2010 for 64 bit systems (same algorithm and results as 32 bit)
+------------------------------------------------------------------------------
+*/
+#ifndef RAND
+#include "rand.h"
+#endif
+
+
+#define ind(mm,x)  ((mm)[(x>>2)&(RANDSIZ-1)])
+#define rngstep(mix,a,b,mm,m,m2,r,x) \
+{ \
+  x = *m;  \
+  a = ((a^(mix)) + *(m2++)); \
+  *(m++) = y = (ind(mm,x) + a + b); \
+  *(r++) = b = (ind(mm,y>>RANDSIZL) + x); \
+}
+
+void isaac_rand(ctx)
+randctx *ctx;
+{
+   register ub4 a,b,x,y,*m,*mm,*m2,*r,*mend;
+   mm=ctx->randmem; r=ctx->randrsl;
+   a = ctx->randa; b = (ctx->randb + (++ctx->randc));
+   for (m = mm, mend = m2 = m+(RANDSIZ/2); m<mend; )
+   {
+      rngstep( a<<13, a, b, mm, m, m2, r, x);
+      rngstep( a>>6 , a, b, mm, m, m2, r, x);
+      rngstep( a<<2 , a, b, mm, m, m2, r, x);
+      rngstep( a>>16, a, b, mm, m, m2, r, x);
+   }
+   for (m2 = mm; m2<mend; )
+   {
+      rngstep( a<<13, a, b, mm, m, m2, r, x);
+      rngstep( a>>6 , a, b, mm, m, m2, r, x);
+      rngstep( a<<2 , a, b, mm, m, m2, r, x);
+      rngstep( a>>16, a, b, mm, m, m2, r, x);
+   }
+   ctx->randb = b; ctx->randa = a;
+}
+
+
+#define mix(a,b,c,d,e,f,g,h) \
+{ \
+   a^=b<<11; d+=a; b+=c; \
+   b^=c>>2;  e+=b; c+=d; \
+   c^=d<<8;  f+=c; d+=e; \
+   d^=e>>16; g+=d; e+=f; \
+   e^=f<<10; h+=e; f+=g; \
+   f^=g>>4;  a+=f; g+=h; \
+   g^=h<<8;  b+=g; h+=a; \
+   h^=a>>9;  c+=h; a+=b; \
+}
+
+/* if (flag==TRUE), then use the contents of randrsl[] to initialize mm[]. */
+void isaac_init(ctx, flag)
+randctx *ctx;
+int     flag;
+{
+   int i;
+   ub4 a,b,c,d,e,f,g,h;
+   ub4 *m,*r;
+   ctx->randa = ctx->randb = ctx->randc = 0;
+   m=ctx->randmem;
+   r=ctx->randrsl;
+   a=b=c=d=e=f=g=h=0x9e3779b9;  /* the golden ratio */
+
+   for (i=0; i<4; ++i)          /* scramble it */
+   {
+     mix(a,b,c,d,e,f,g,h);
+   }
+
+   if (flag) 
+   {
+     /* initialize using the contents of r[] as the seed */
+     for (i=0; i<RANDSIZ; i+=8)
+     {
+       a+=r[i  ]; b+=r[i+1]; c+=r[i+2]; d+=r[i+3];
+       e+=r[i+4]; f+=r[i+5]; g+=r[i+6]; h+=r[i+7];
+       mix(a,b,c,d,e,f,g,h);
+       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
+       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+     }
+     /* do a second pass to make all of the seed affect all of m */
+     for (i=0; i<RANDSIZ; i+=8)
+     {
+       a+=m[i  ]; b+=m[i+1]; c+=m[i+2]; d+=m[i+3];
+       e+=m[i+4]; f+=m[i+5]; g+=m[i+6]; h+=m[i+7];
+       mix(a,b,c,d,e,f,g,h);
+       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
+       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+     }
+   }
+   else
+   {
+     /* fill in mm[] with messy stuff */
+     for (i=0; i<RANDSIZ; i+=8)
+     {
+       mix(a,b,c,d,e,f,g,h);
+       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
+       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+     }
+   }
+
+   isaac_rand(ctx);            /* fill in the first set of results */
+   ctx->randcnt=RANDSIZ;  /* prepare to use the first set of results */
+}
+
+
+#ifdef NEVER
+#include <stdio.h>
+
+int main()
+{
+  ub4 i,j;
+  randctx ctx;
+  ctx.randa=ctx.randb=ctx.randc=(ub4)0;
+  for (i=0; i<RANDSIZ; ++i) ctx.randrsl[i]=(ub4)0;
+  isaac_init(&ctx, 1);
+  for (i=0; i<2; ++i)
+  {
+    isaac_rand(&ctx);
+    for (j=0; j<RANDSIZ; ++j)
+    {
+      printf("%.8lx",(long unsigned int)ctx.randrsl[j]);
+      if ((j&7)==7) printf("\n");
+    }
+  }
+}
+#endif

data/ext/isaac/rand.h

@@ -0,0 +1,60 @@
+/*
+------------------------------------------------------------------------------
+rand.h: definitions for a random number generator
+By Bob Jenkins, 1996, Public Domain
+MODIFIED:
+  960327: Creation (addition of randinit, really)
+  970719: use context, not global variables, for internal state
+  980324: renamed seed to flag
+  980605: recommend RANDSIZL=4 for noncryptography.
+  010626: note this is public domain
+
+ADAPTED Aug2004 for use in Ruby by Joel VanderWerf
+ADAPTED Jan2010 for 64 bit systems (same algorithm and results as 32 bit)
+------------------------------------------------------------------------------
+*/
+
+#include <stdint.h>
+
+typedef uint32_t ub4;
+
+#ifndef RAND
+#define RAND
+#define RANDSIZL   (8)  /* I recommend 8 for crypto, 4 for simulations */
+#define RANDSIZ    (1<<RANDSIZL)
+
+/* context of random number generator */
+struct randctx
+{
+  ub4 randcnt;
+  ub4 randrsl[RANDSIZ];
+  ub4 randmem[RANDSIZ];
+  ub4 randa;
+  ub4 randb;
+  ub4 randc;
+};
+typedef  struct randctx  randctx;
+
+/*
+------------------------------------------------------------------------------
+ If (flag==TRUE), then use the contents of randrsl[0..RANDSIZ-1] as the seed.
+------------------------------------------------------------------------------
+*/
+void isaac_init(randctx *r, int flag);
+
+void isaac_rand(randctx *r);
+
+
+/*
+------------------------------------------------------------------------------
+ Call rand(/o_ randctx *r _o/) to retrieve a single 32-bit random value
+------------------------------------------------------------------------------
+*/
+#define rand(r) \
+   (!(r)->randcnt-- ? \
+     (isaac_rand(r), (r)->randcnt=RANDSIZ-1, (r)->randrsl[(r)->randcnt]) : \
+     (r)->randrsl[(r)->randcnt])
+
+#endif  /* RAND */
+
+

data/ext/isaac/rand4.c

@@ -0,0 +1,131 @@
+/*
+------------------------------------------------------------------------------
+rand4.c: rand.c specialized to RANDSIZL=4
+------------------------------------------------------------------------------
+*/
+#ifndef RAND4
+#include "rand4.h"
+#endif
+
+
+#define ind(mm,x)  ((mm)[(x>>2)&(RANDSIZ4-1)])
+#define rngstep(mix,a,b,mm,m,m2,r,x) \
+{ \
+  x = *m;  \
+  a = ((a^(mix)) + *(m2++)); \
+  *(m++) = y = (ind(mm,x) + a + b); \
+  *(r++) = b = (ind(mm,y>>4) + x); \
+}
+
+void isaac_rand4(ctx)
+randctx4 *ctx;
+{
+   register ub4 a,b,x,y,*m,*mm,*m2,*r,*mend;
+   mm=ctx->randmem; r=ctx->randrsl;
+   a = ctx->randa; b = (ctx->randb + (++ctx->randc));
+   for (m = mm, mend = m2 = m+(RANDSIZ4/2); m<mend; )
+   {
+      rngstep( a<<13, a, b, mm, m, m2, r, x);
+      rngstep( a>>6 , a, b, mm, m, m2, r, x);
+      rngstep( a<<2 , a, b, mm, m, m2, r, x);
+      rngstep( a>>16, a, b, mm, m, m2, r, x);
+   }
+   for (m2 = mm; m2<mend; )
+   {
+      rngstep( a<<13, a, b, mm, m, m2, r, x);
+      rngstep( a>>6 , a, b, mm, m, m2, r, x);
+      rngstep( a<<2 , a, b, mm, m, m2, r, x);
+      rngstep( a>>16, a, b, mm, m, m2, r, x);
+   }
+   ctx->randb = b; ctx->randa = a;
+}
+
+
+#define mix(a,b,c,d,e,f,g,h) \
+{ \
+   a^=b<<11; d+=a; b+=c; \
+   b^=c>>2;  e+=b; c+=d; \
+   c^=d<<8;  f+=c; d+=e; \
+   d^=e>>16; g+=d; e+=f; \
+   e^=f<<10; h+=e; f+=g; \
+   f^=g>>4;  a+=f; g+=h; \
+   g^=h<<8;  b+=g; h+=a; \
+   h^=a>>9;  c+=h; a+=b; \
+}
+
+/* if (flag==TRUE), then use the contents of randrsl[] to initialize mm[]. */
+void isaac_init4(ctx, flag)
+randctx4 *ctx;
+int     flag;
+{
+   int i;
+   ub4 a,b,c,d,e,f,g,h;
+   ub4 *m,*r;
+   ctx->randa = ctx->randb = ctx->randc = 0;
+   m=ctx->randmem;
+   r=ctx->randrsl;
+   a=b=c=d=e=f=g=h=0x9e3779b9;  /* the golden ratio */
+
+   for (i=0; i<4; ++i)          /* scramble it */
+   {
+     mix(a,b,c,d,e,f,g,h);
+   }
+
+   if (flag) 
+   {
+     /* initialize using the contents of r[] as the seed */
+     for (i=0; i<RANDSIZ4; i+=8)
+     {
+       a+=r[i  ]; b+=r[i+1]; c+=r[i+2]; d+=r[i+3];
+       e+=r[i+4]; f+=r[i+5]; g+=r[i+6]; h+=r[i+7];
+       mix(a,b,c,d,e,f,g,h);
+       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
+       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+     }
+     /* do a second pass to make all of the seed affect all of m */
+     for (i=0; i<RANDSIZ4; i+=8)
+     {
+       a+=m[i  ]; b+=m[i+1]; c+=m[i+2]; d+=m[i+3];
+       e+=m[i+4]; f+=m[i+5]; g+=m[i+6]; h+=m[i+7];
+       mix(a,b,c,d,e,f,g,h);
+       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
+       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+     }
+   }
+   else
+   {
+     /* fill in mm[] with messy stuff */
+     for (i=0; i<RANDSIZ4; i+=8)
+     {
+       mix(a,b,c,d,e,f,g,h);
+       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
+       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+     }
+   }
+
+   isaac_rand4(ctx);            /* fill in the first set of results */
+   ctx->randcnt=RANDSIZ4;  /* prepare to use the first set of results */
+}
+
+
+#ifdef NEVER
+#include <stdio.h>
+
+int main()
+{
+  ub4 i,j;
+  randctx4 ctx;
+  ctx.randa=ctx.randb=ctx.randc=(ub4)0;
+  for (i=0; i<RANDSIZ4; ++i) ctx.randrsl[i]=(ub4)0;
+  isaac_init4(&ctx, 1);
+  for (i=0; i<2; ++i)
+  {
+    isaac_rand4(&ctx);
+    for (j=0; j<RANDSIZ4; ++j)
+    {
+      printf("%.8lx",(long unsigned int)ctx.randrsl[j]);
+      if ((j&7)==7) printf("\n");
+    }
+  }
+}
+#endif

data/ext/isaac/rand4.h

@@ -0,0 +1,49 @@
+/*
+------------------------------------------------------------------------------
+rand4.h: rand.h specialized to RANDSIZL=4
+------------------------------------------------------------------------------
+*/
+
+#include <stdint.h>
+
+#include "rand.h"
+
+#ifndef RAND4
+#define RAND4
+#define RANDSIZ4    (1<<4)
+
+/* context of random number generator */
+struct randctx4
+{
+  ub4 randcnt;
+  ub4 randrsl[RANDSIZ4];
+  ub4 randmem[RANDSIZ4];
+  ub4 randa;
+  ub4 randb;
+  ub4 randc;
+};
+typedef  struct randctx4  randctx4;
+
+/*
+------------------------------------------------------------------------------
+ If (flag==TRUE), then use the contents of randrsl[0..RANDSIZ4-1] as the seed.
+------------------------------------------------------------------------------
+*/
+void isaac_init4(randctx4 *r, int flag);
+
+void isaac_rand4(randctx4 *r);
+
+
+/*
+------------------------------------------------------------------------------
+ Call rand4(/o_ randctx4 *r _o/) to retrieve a single 32-bit random value
+------------------------------------------------------------------------------
+*/
+#define rand4(r) \
+   (!(r)->randcnt-- ? \
+     (isaac_rand4(r), (r)->randcnt=RANDSIZ4-1, (r)->randrsl[(r)->randcnt]) : \
+     (r)->randrsl[(r)->randcnt])
+
+#endif  /* RAND4 */
+
+

data/lib/tuplex/version.rb

@@ -0,0 +1,3 @@
+module Tuplex
+  VERSION = "0.1"
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: tuplex
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Joel VanderWerf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-01 00:00:00.000000000 Z
+dependencies: []
+description: Constructs index keys for tuples.
+email: vjoel@users.sourceforge.net
+executables: []
+extensions:
+- ext/isaac/extconf.rb
+extra_rdoc_files:
+- README.md
+- COPYING
+files:
+- COPYING
+- README.md
+- ext/isaac/extconf.rb
+- ext/isaac/isaac.c
+- ext/isaac/rand.c
+- ext/isaac/rand.h
+- ext/isaac/rand4.c
+- ext/isaac/rand4.h
+- lib/tuplex/version.rb
+homepage: https://github.com/vjoel/tuplex
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--quiet"
+- "--line-numbers"
+- "--inline-source"
+- "--title"
+- Tuplex
+- "--main"
+- README.md
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: Tuple index.
+test_files: []
+has_rdoc: