ent 0.0.2

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format nested
+-b

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.3.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+  gem "rake-compiler", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,3 @@
+Copyright (c) 2011 Eric Monti
+
+This software is in the public domain. Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, without any conditions or restrictions. This software is provided “as is” without express or implied warranty. 

data/README.rdoc

@@ -0,0 +1,8 @@
+= ent
+
+A ruby native library for entropy tests ala the ent util from fourmilab.ch/random
+
+== Copyright
+
+Copyright (c) 2011 Eric Monti. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake'
+require 'rake/extensiontask'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "ent"
+  gem.homepage = "http://github.com/emonti/ent"
+  gem.license = "MIT"
+  gem.summary = %Q{Calculate the entropy of data}
+  gem.description = %Q{Calculate the entropy of data}
+  gem.email = "esmonti@gmail.com"
+  gem.authors = ["Eric Monti"]
+
+  gem.extensions = FileList['ext/**/extconf.rb']
+  gem.extra_rdoc_files += FileList['ext/**/*.c']
+
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+Rake::ExtensionTask.new("ent_native")
+
+CLEAN.include("lib/*.bundle")
+CLEAN.include("ext/ent_native/*.bundle")
+CLEAN.include("ext/ent_native/*.o")
+CLEAN.include("ext/ent_native/Makefile")
+CLEAN.include("ext/ent_native/mkmf.log")
+CLEAN.include("ext/ent_native/extconf.h")
+CLEAN.include("lib/*.so")
+CLEAN.include("tmp/")
+CLEAN.include("doc/")
+CLEAN.include("rdoc/")
+CLEAN.include("coverage/")
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ent #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/ext/ent_native/chisq.c

@@ -0,0 +1,136 @@
+/*
+
+    Compute probability of measured Chi Square value.
+    
+    This code was developed by Gary Perlman of the Wang
+    Institute (full citation below) and has been minimally
+    modified for use in this program.
+    
+*/
+
+#include <math.h>
+
+/*HEADER
+	Module:       z.c
+	Purpose:      compute approximations to normal z distribution probabilities
+	Programmer:   Gary Perlman
+	Organization: Wang Institute, Tyngsboro, MA 01879
+	Copyright:    none
+	Tabstops:     4
+*/
+
+#define	Z_MAX          6.0            /* maximum meaningful z value */
+
+/*FUNCTION poz: probability of normal z value */
+/*ALGORITHM
+	Adapted from a polynomial approximation in:
+		Ibbetson D, Algorithm 209
+		Collected Algorithms of the CACM 1963 p. 616
+	Note:
+		This routine has six digit accuracy, so it is only useful for absolute
+		z values < 6.  For z values >= to 6.0, poz() returns 0.0.
+*/
+static double        /*VAR returns cumulative probability from -oo to z */
+poz(const double z)  /*VAR normal z value */
+{
+    double y, x, w;
+
+    if (z == 0.0) {
+    	x = 0.0;
+    } else {
+	y = 0.5 * fabs(z);
+	if (y >= (Z_MAX * 0.5)) {
+    	    x = 1.0;
+	} else if (y < 1.0) {
+	   w = y * y;
+	   x = ((((((((0.000124818987 * w
+		   -0.001075204047) * w +0.005198775019) * w
+		   -0.019198292004) * w +0.059054035642) * w
+		   -0.151968751364) * w +0.319152932694) * w
+		   -0.531923007300) * w +0.797884560593) * y * 2.0;
+	} else {
+	    y -= 2.0;
+	    x = (((((((((((((-0.000045255659 * y
+		    +0.000152529290) * y -0.000019538132) * y
+		    -0.000676904986) * y +0.001390604284) * y
+		    -0.000794620820) * y -0.002034254874) * y
+		    +0.006549791214) * y -0.010557625006) * y
+		    +0.011630447319) * y -0.009279453341) * y
+		    +0.005353579108) * y -0.002141268741) * y
+		    +0.000535310849) * y +0.999936657524;
+    	}
+    }
+    return (z > 0.0 ? ((x + 1.0) * 0.5) : ((1.0 - x) * 0.5));
+}
+
+/*
+	Module:       chisq.c
+	Purpose:      compute approximations to chisquare distribution probabilities
+	Contents:     pochisq()
+	Uses:         poz() in z.c (Algorithm 209)
+	Programmer:   Gary Perlman
+	Organization: Wang Institute, Tyngsboro, MA 01879
+	Copyright:    none
+	Tabstops:     4
+*/
+
+#define	LOG_SQRT_PI     0.5723649429247000870717135 /* log (sqrt (pi)) */
+#define	I_SQRT_PI       0.5641895835477562869480795 /* 1 / sqrt (pi) */
+#define	BIGX           20.0         /* max value to represent exp (x) */
+#define	ex(x)             (((x) < -BIGX) ? 0.0 : exp(x))
+
+/*FUNCTION pochisq: probability of chi sqaure value */
+/*ALGORITHM Compute probability of chi square value.
+	Adapted from:
+		Hill, I. D. and Pike, M. C.  Algorithm 299
+		Collected Algorithms for the CACM 1967 p. 243
+	Updated for rounding errors based on remark in
+		ACM TOMS June 1985, page 185
+*/
+
+double pochisq(
+    	const double ax,    /* obtained chi-square value */
+     	const int df	    /* degrees of freedom */
+     	)
+{
+    double x = ax;
+    double a, y, s;
+    double e, c, z;
+    int even;	    	    /* true if df is an even number */
+
+    if (x <= 0.0 || df < 1) {
+    	return 1.0;
+    }
+
+    a = 0.5 * x;
+    even = (2 * (df / 2)) == df;
+    if (df > 1) {
+    	y = ex(-a);
+    }
+    s = (even ? y : (2.0 * poz(-sqrt(x))));
+    if (df > 2) {
+	x = 0.5 * (df - 1.0);
+	z = (even ? 1.0 : 0.5);
+	if (a > BIGX) {
+    	    e = (even ? 0.0 : LOG_SQRT_PI);
+    	    c = log(a);
+    	    while (z <= x) {
+		e = log(z) + e;
+		s += ex(c * z - a - e);
+		z += 1.0;
+    	    }
+    	    return (s);
+    	} else {
+	    e = (even ? 1.0 : (I_SQRT_PI / sqrt(a)));
+	    c = 0.0;
+	    while (z <= x) {
+		    e = e * (a / z);
+		    c = c + e;
+		    z += 1.0;
+    	    }
+	    return (c * y + s);
+    	}
+    } else {
+    	return s;
+    }
+}

data/ext/ent_native/ent_native.c

@@ -0,0 +1,277 @@
+#include "ruby.h"
+
+#include "randtest.h"
+#include "iso8859.h"
+
+
+#ifndef DBL2NUM
+#define DBL2NUM(dbl)  rb_float_new(dbl)
+#endif
+
+extern void rt_init();
+
+extern rt_ctx *rt_new();
+extern void rt_add(rt_ctx *ctx, void *buf, int bufl);
+extern void rt_end(rt_ctx *ctx);
+extern void rt_free(rt_ctx *ctx);
+
+
+VALUE m_ent = Qnil;
+VALUE c_random_test = Qnil;
+
+VALUE rb_rt_assert_open(rt_ctx *ctx) {
+  if(ctx->ended)
+    rb_raise(rb_eIOError, "closed stream");
+
+  return Qnil;
+}
+
+void rb_rt_mark(rt_ctx *ctx) { }
+
+VALUE rb_rt_initialize(int argc, VALUE *argv, VALUE klass) {
+  rt_ctx *ctx;
+  VALUE binmode = Qnil;
+  int _bmode = 0;
+
+  rb_scan_args(argc, argv, "01", &binmode);
+  if ((binmode != Qnil) && (binmode != Qfalse)) {
+    Check_Type(binmode, T_TRUE);
+    _bmode=1;
+  }
+
+  if(!(ctx = rt_new()))
+    rb_sys_fail(0);
+
+  ctx->binary = _bmode;
+
+  return Data_Wrap_Struct(klass, rb_rt_mark, rt_free, ctx);
+}
+
+
+VALUE rb_rt_get_binmode(VALUE self) {
+  rt_ctx *ctx;
+  Data_Get_Struct(self, rt_ctx, ctx);
+  if (ctx->binary)
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+
+VALUE rb_rt_final(VALUE self) {
+  rt_ctx *ctx;
+  Data_Get_Struct(self, rt_ctx, ctx);
+
+  if (! ctx->ended) 
+    rt_end(ctx);
+
+  return self;
+}
+
+VALUE rb_rt_read_string(VALUE self, VALUE rb_buf) {
+  rt_ctx *ctx;
+
+  Check_Type(rb_buf, T_STRING);
+
+  Data_Get_Struct(self, rt_ctx, ctx);
+  if(ctx->ended)
+    rb_raise(rb_eIOError, "data cannot be added after finalizing");
+
+  rt_add(ctx, RSTRING_PTR(rb_buf), RSTRING_LEN(rb_buf));
+  return LONG2NUM(RSTRING_LEN(rb_buf));
+}
+
+
+VALUE rb_rt_read_file(VALUE self, VALUE rb_filename) {
+  rt_ctx *ctx;
+
+  Check_Type(rb_filename, T_STRING);
+
+  Data_Get_Struct(self, rt_ctx, ctx);
+  if(ctx->ended)
+    rb_raise(rb_eIOError, "data cannot be added after finalizing");
+
+  // todo ...
+  return Qnil;
+}
+
+
+VALUE rb_rt_entropy(VALUE self) {
+  rt_ctx *ctx;
+  Data_Get_Struct(self, rt_ctx, ctx);
+
+  if(ctx->ended)
+    return DBL2NUM(ctx->r_ent);
+  else
+    return Qnil;
+}
+
+
+VALUE rb_rt_mean(VALUE self) {
+  rt_ctx *ctx;
+  Data_Get_Struct(self, rt_ctx, ctx);
+
+  if(ctx->ended)
+    return DBL2NUM(ctx->r_mean);
+  else
+    return Qnil;
+}
+
+
+VALUE rb_rt_chisquare(VALUE self) {
+  rt_ctx *ctx;
+  Data_Get_Struct(self, rt_ctx, ctx);
+
+  if(ctx->ended)
+    return DBL2NUM(ctx->r_chisq);
+  else
+    return Qnil;
+}
+
+
+VALUE rb_rt_datasum(VALUE self) {
+  rt_ctx *ctx;
+  Data_Get_Struct(self, rt_ctx, ctx);
+
+  if(ctx->ended)
+    return DBL2NUM(ctx->r_datasum);
+  else
+    return Qnil;
+}
+
+
+VALUE rb_rt_montepi(VALUE self) {
+  rt_ctx *ctx;
+  Data_Get_Struct(self, rt_ctx, ctx);
+
+  if(ctx->ended)
+    return DBL2NUM(ctx->r_montepicalc);
+  else
+    return Qnil;
+}
+
+
+VALUE rb_rt_scc(VALUE self) {
+  rt_ctx *ctx;
+  Data_Get_Struct(self, rt_ctx, ctx);
+
+  if(ctx->ended)
+    return DBL2NUM(ctx->r_scc);
+  else
+    return Qnil;
+}
+
+VALUE rb_rt_entropy_force(VALUE self) {
+  rt_ctx *ctx;
+  Data_Get_Struct(self, rt_ctx, ctx);
+
+  if(! ctx->ended)
+    rt_end(ctx);
+
+  return DBL2NUM(ctx->r_ent);
+}
+
+
+VALUE rb_rt_mean_force(VALUE self) {
+  rt_ctx *ctx;
+  Data_Get_Struct(self, rt_ctx, ctx);
+
+  if(! ctx->ended)
+    rt_end(ctx);
+
+  return DBL2NUM(ctx->r_mean);
+}
+
+
+VALUE rb_rt_chisquare_force(VALUE self) {
+  rt_ctx *ctx;
+  Data_Get_Struct(self, rt_ctx, ctx);
+
+  if(! ctx->ended)
+    rt_end(ctx);
+
+  return DBL2NUM(ctx->r_chisq);
+}
+
+
+VALUE rb_rt_datasum_force(VALUE self) {
+  rt_ctx *ctx;
+  Data_Get_Struct(self, rt_ctx, ctx);
+
+  if(! ctx->ended)
+    rt_end(ctx);
+
+  return DBL2NUM(ctx->r_datasum);
+}
+
+
+VALUE rb_rt_montepi_force(VALUE self) {
+  rt_ctx *ctx;
+  Data_Get_Struct(self, rt_ctx, ctx);
+
+  if(! ctx->ended)
+    rt_end(ctx);
+
+  return DBL2NUM(ctx->r_montepicalc);
+}
+
+
+VALUE rb_rt_scc_force(VALUE self) {
+  rt_ctx *ctx;
+  Data_Get_Struct(self, rt_ctx, ctx);
+
+  if(! ctx->ended)
+    rt_end(ctx);
+
+  return DBL2NUM(ctx->r_scc);
+}
+
+VALUE rb_rt_result(VALUE self) {
+  rt_ctx *ctx;
+  VALUE ret;
+
+  Data_Get_Struct(self, rt_ctx, ctx);
+
+  if(! ctx->ended)
+    rt_end(ctx);
+
+  ret = rb_hash_new();
+  rb_hash_aset(ret, ID2SYM(rb_intern("entropy")), DBL2NUM(ctx->r_ent));
+  rb_hash_aset(ret, ID2SYM(rb_intern("mean")), DBL2NUM(ctx->r_mean));
+  rb_hash_aset(ret, ID2SYM(rb_intern("chisquare")), DBL2NUM(ctx->r_chisq));
+  rb_hash_aset(ret, ID2SYM(rb_intern("datasum")), DBL2NUM(ctx->r_datasum));
+  rb_hash_aset(ret, ID2SYM(rb_intern("montepi")), DBL2NUM(ctx->r_montepicalc));
+  rb_hash_aset(ret, ID2SYM(rb_intern("scc")), DBL2NUM(ctx->r_scc));
+  return ret;
+}
+
+void Init_ent_native() {
+  rt_init();
+
+  m_ent = rb_define_module("Ent");
+
+  c_random_test = rb_define_class_under(m_ent, "RandomTest", rb_cObject);
+
+  rb_define_singleton_method(c_random_test, "new", rb_rt_initialize, -1);
+  rb_define_method(c_random_test, "binary?", rb_rt_get_binmode, 0);
+
+  rb_define_method(c_random_test, "read", rb_rt_read_string, 1);
+//  rb_define_method(c_random_test, "read_string", rb_rt_read_string, 1);
+//  rb_define_method(c_random_test, "read_file", rb_rt_read_file, 1);
+  rb_define_method(c_random_test, "finalize", rb_rt_final, 0);
+  rb_define_method(c_random_test, "result", rb_rt_result, 0);
+  rb_define_method(c_random_test, "entropy", rb_rt_entropy, 0);
+  rb_define_method(c_random_test, "mean", rb_rt_mean, 0);
+  rb_define_method(c_random_test, "chisquare", rb_rt_chisquare, 0);
+  rb_define_method(c_random_test, "datasum", rb_rt_datasum, 0);
+  rb_define_method(c_random_test, "montepi", rb_rt_montepi, 0);
+  rb_define_method(c_random_test, "scc", rb_rt_scc, 0);
+  rb_define_method(c_random_test, "entropy!", rb_rt_entropy_force, 0);
+  rb_define_method(c_random_test, "mean!", rb_rt_mean_force, 0);
+  rb_define_method(c_random_test, "chisquare!", rb_rt_chisquare_force, 0);
+  rb_define_method(c_random_test, "datasum!", rb_rt_datasum_force, 0);
+  rb_define_method(c_random_test, "montepi!", rb_rt_montepi_force, 0);
+  rb_define_method(c_random_test, "scc!", rb_rt_scc_force, 0);
+ }
+
+

data/ext/ent_native/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+require 'rbconfig'
+
+extension_name = "ent_native"
+have_library('m')
+dir_config(extension_name)
+create_makefile(extension_name)
+

data/ext/ent_native/iso8859.c

@@ -0,0 +1,19 @@
+
+/* ISO 8859/1 Latin-1 alphabetic and upper and lower case bit vector tables. */
+
+/* LINTLIBRARY */
+
+unsigned char isoalpha[32] = {
+    0,0,0,0,0,0,0,0,127,255,255,224,127,255,255,224,0,0,0,0,0,0,0,0,255,255,
+    254,255,255,255,254,255
+};
+
+unsigned char isoupper[32] = {
+    0,0,0,0,0,0,0,0,127,255,255,224,0,0,0,0,0,0,0,0,0,0,0,0,255,255,254,254,
+    0,0,0,0
+};
+
+unsigned char isolower[32] = {
+    0,0,0,0,0,0,0,0,0,0,0,0,127,255,255,224,0,0,0,0,0,0,0,0,0,0,0,1,255,255,
+    254,255
+};

data/ext/ent_native/iso8859.h

@@ -0,0 +1,17 @@
+
+/* ISO 8859/1 Latin-1 "ctype" macro replacements. */
+
+extern unsigned char isoalpha[32], isoupper[32], isolower[32];
+
+#define isISOspace(x)	((isascii(((unsigned char) (x))) && isspace(((unsigned char) (x)))) || ((x) == 0xA0))
+#define isISOalpha(x)	((isoalpha[(((unsigned char) (x))) / 8] & (0x80 >> ((((unsigned char) (x))) % 8))) != 0)
+#define isISOupper(x)	((isoupper[(((unsigned char) (x))) / 8] & (0x80 >> ((((unsigned char) (x))) % 8))) != 0)
+#define isISOlower(x)	((isolower[(((unsigned char) (x))) / 8] & (0x80 >> ((((unsigned char) (x))) % 8))) != 0)
+#define isISOprint(x)   ((((x) >= ' ') && ((x) <= '~')) || ((x) >= 0xA0))
+#define toISOupper(x)   (isISOlower(x) ? (isascii(((unsigned char) (x))) ?  \
+                            toupper(x) : (((((unsigned char) (x)) != 0xDF) && \
+                            (((unsigned char) (x)) != 0xFF)) ? \
+			    (((unsigned char) (x)) - 0x20) : (x))) : (x))
+#define toISOlower(x)   (isISOupper(x) ? (isascii(((unsigned char) (x))) ?  \
+                            tolower(x) : (((unsigned char) (x)) + 0x20)) \
+			    : (x))

data/ext/ent_native/randtest.c

@@ -0,0 +1,167 @@
+/*
+
+   Apply various randomness tests to a stream of bytes
+
+      by John Walker  --  September 1996
+           http://www.fourmilab.ch/
+
+
+      Minor modifications made for use as a library
+      in ruby bindings -- Eric Monti
+*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <strings.h>
+#include "randtest.h"
+
+#define FALSE 0
+#define TRUE  1
+
+static double incirc; /* In-circle distance for Monte Carlo */
+
+#define log2of10 3.32192809488736234787
+static double rt_log2(double x)
+{
+    return log2of10 * log10(x);
+}
+
+void rt_init() {
+    incirc = pow(pow(256.0, (double) (MONTEN / 2)) - 1, 2.0);
+}
+
+/*  RT_INIT  --  Initialise random test counters.  */
+rt_ctx * rt_new()
+{
+    rt_ctx * ctx;
+
+    if (ctx=(rt_ctx *) malloc(sizeof(rt_ctx))) {
+      bzero(ctx, sizeof(rt_ctx));
+
+      /* Initialise for calculations */
+      ctx->sccfirst = TRUE;         /* Mark first time for serial correlation */
+    }
+
+    return ctx;
+}
+
+/*  RT_ADD  --  Add one or more bytes to accumulation.  */
+
+void rt_add(rt_ctx * ctx, void *buf, size_t bufl)
+{
+    unsigned char *bp = buf;
+    int oc, c, bean;
+
+    while (bean = 0, (bufl-- > 0)) {
+       oc = *bp++;
+
+       do {
+	  if (ctx->binary) {
+	     c = !!(oc & 0x80);
+	  } else {
+	     c = oc;
+	  }
+	  ctx->ccount[c]++;		  /* Update counter for this bin */
+	  ctx->totalc++;
+
+	  /* Update inside / outside circle counts for Monte Carlo
+	     computation of PI */
+
+	  if (bean == 0) {
+	      ctx->monte[ctx->mp++] = oc;       /* Save character for Monte Carlo */
+	      if (ctx->mp >= MONTEN) {     /* Calculate every MONTEN character */
+		 int mj;
+
+		 ctx->mp = 0;
+		 ctx->mcount++;
+		 ctx->montex = ctx->montey = 0;
+		 for (mj = 0; mj < MONTEN / 2; mj++) {
+		    ctx->montex = (ctx->montex * 256.0) + ctx->monte[mj];
+		    ctx->montey = (ctx->montey * 256.0) + ctx->monte[(MONTEN / 2) + mj];
+		 }
+		 if ((ctx->montex * ctx->montex + ctx->montey *  ctx->montey) <= incirc) {
+		    ctx->inmont++;
+		 }
+	      }
+	  }
+
+	  /* Update calculation of serial correlation coefficient */
+
+	  ctx->sccun = c;
+	  if (ctx->sccfirst) {
+	     ctx->sccfirst = FALSE;
+	     ctx->scclast = 0;
+	     ctx->sccu0 = ctx->sccun;
+	  } else {
+	     ctx->scct1 = ctx->scct1 + ctx->scclast * ctx->sccun;
+	  }
+	  ctx->scct2 = ctx->scct2 + ctx->sccun;
+	  ctx->scct3 = ctx->scct3 + (ctx->sccun * ctx->sccun);
+	  ctx->scclast = ctx->sccun;
+	  oc <<= 1;
+       } while (ctx->binary && (++bean < 8));
+    }
+}
+
+/*  RT_END  --	Complete calculation and return results.  */
+
+void rt_end(rt_ctx * ctx)
+{
+    int i;
+    double ent, chisq, datasum, montepi, scc;
+    ent = chisq = datasum = montepi = scc = 0.0;
+
+    /* Complete calculation of serial correlation coefficient */
+
+    ctx->scct1 = ctx->scct1 + ctx->scclast * ctx->sccu0;
+    ctx->scct2 = ctx->scct2 * ctx->scct2;
+    scc = ctx->totalc * ctx->scct3 - ctx->scct2;
+    if (scc == 0.0) {
+       scc = -100000;
+    } else {
+       scc = (ctx->totalc * ctx->scct1 - ctx->scct2) / scc;
+    }
+
+    /* Scan bins and calculate probability for each bin and
+       Chi-Square distribution.  The probability will be reused
+       in the entropy calculation below.  While we're at it,
+       we sum of all the data which will be used to compute the
+       mean. */
+       
+    /* Expected count per bin */
+    ctx->cexp = ctx->totalc / (ctx->binary ? 2.0 : 256.0);  
+
+    for (i = 0; i < (ctx->binary ? 2 : 256); i++) {
+       double a = ctx->ccount[i] - ctx->cexp;;
+       
+       ctx->prob[i] = ((double) ctx->ccount[i]) / ctx->totalc;       
+       chisq += (a * a) / ctx->cexp;
+       datasum += ((double) i) * ctx->ccount[i];
+    }
+
+    /* Calculate entropy */
+
+    for (i = 0; i < (ctx->binary ? 2 : 256); i++) {
+       if (ctx->prob[i] > 0.0) {
+	  ent += ctx->prob[i] * rt_log2(1 / ctx->prob[i]);
+       }
+    }
+
+    /* Calculate Monte Carlo value for PI from percentage of hits
+       within the circle */
+
+    montepi = 4.0 * (((double) ctx->inmont) / ctx->mcount);
+
+    /* Return results through arguments */
+
+    ctx->r_ent = ent;
+    ctx->r_chisq = chisq;
+    ctx->r_mean = datasum / ctx->totalc;
+    ctx->r_montepicalc = montepi;
+    ctx->r_scc = scc;
+    ctx->ended = 1;
+}
+
+void rt_free(rt_ctx *ctx) {
+  free(ctx);
+}

data/ext/ent_native/randtest.h

@@ -0,0 +1,35 @@
+#define MONTEN  6          /* Bytes used as Monte Carlo co-ordinates.  
+                              This should be no more bits than the mantissa
+                              of your "double" floating point type. */
+
+
+typedef struct {
+  int    binary;              /* use byte(0) or binary(1) mode ? */
+  int    sccfirst;            /* first time for serial correlation ? */
+  size_t totalc;              /* Total bytes counted */
+  int    mp;                  /* Monte Carlo accumulator pointer */
+  size_t inmont;              /* Monte Carlo inside count */
+  size_t mcount;              /* Monte Carlo tries */
+  double cexp;
+  double montex;
+  double montey;
+  double sccun;
+  double sccu0;
+  double scclast;
+  double scct1;               /* serial correlation term 1 */
+  double scct2;               /* serial correlation term 2 */
+  double scct3;               /* serial correlation term 3 */
+  unsigned int monte[MONTEN]; /* Monte Carlo co-ordinates */
+  size_t ccount[256];         /* Bins to count occurrences of values */
+  double prob[256];           /* Probabilities per bin for entropy */
+
+  int    ended;
+  double r_ent;
+  double r_mean;
+  double r_chisq;
+  double r_datasum;
+  double r_montepicalc;
+  double r_scc;
+} rt_ctx;
+
+

data/lib/ent.rb

@@ -0,0 +1,2 @@
+
+require 'ent_native'

data/spec/ent_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Ent" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'ent'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification 
+name: ent
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Eric Monti
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-10 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rake-compiler
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Calculate the entropy of data
+email: esmonti@gmail.com
+executables: []
+
+extensions: 
+- ext/ent_native/extconf.rb
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+- ext/ent_native/chisq.c
+- ext/ent_native/ent_native.c
+- ext/ent_native/iso8859.c
+- ext/ent_native/randtest.c
+files: 
+- .document
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- ext/ent_native/chisq.c
+- ext/ent_native/ent_native.c
+- ext/ent_native/extconf.rb
+- ext/ent_native/iso8859.c
+- ext/ent_native/iso8859.h
+- ext/ent_native/randtest.c
+- ext/ent_native/randtest.h
+- lib/ent.rb
+- spec/ent_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/emonti/ent
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Calculate the entropy of data
+test_files: 
+- spec/ent_spec.rb
+- spec/spec_helper.rb