ruby-gsl-ngx 0.2.6.1

data/.gitignore

@@ -0,0 +1,11 @@
+ext/Makefile
+ext/*.so
+ext/*.o
+ext/mkmf.log
+doc
+.yardoc
+pkg
+lib/*.so
+*~
+*.swp
+*.swo

data/History.txt

@@ -0,0 +1,62 @@
+=== 0.2.6
+* Features:
+  * Improved Vector#wrap
+  * Performance improvements
+  * Check for pkg-config, to avoid problems
+  * Vector#median (bdigital)
+  * Added Vector.linspace, Vector#hash, Matrix#set, Vector#eql?, Matrix#slide, Vector#quantile
+  * Extend Array to include #to_v and #to_m (bdigital)
+* Fixes:
+  * Better plotter process closing
+  * Clear C/CXXFLAGS
+  * Pointer conversion bug causing random segfaults
+  * Problem while trying to free GSL memory
+=== 0.2.4.1
+* Fixes:
+  * Gnuplot not being correctly executed
+  * plotting.cpp didn't compile on some systems
+=== 0.2.4
+* Features:
+  * Plotting support (using gnuplot) (Plotter class and associated methods on Matrix).
+  * Added Matrix#map_array (just like Vector#map_array)
+  * C version of operator []
+  * Support for some statistics operations in Vector
+  * Updated documentation to use YARD's @group feature
+* Internal Changes:
+  * GSL memory is managed by FFI::AutoPointer now
+* Fixes
+  * On some systems, with Ruby 1.8 the extension was missing libstdc++ support
+=== 0.2.3
+* FIXES:
+  * HUGE memory leak, no GSL object was ever freed.
+  * Remove -march flag for MAC
+* LOTS of improvements:
+  * Added map_array: a map() version that actually returns an Array instead of a Vector/Matrix
+  * Now you use the & idiom for map methods and such (like map_array(&:to_s))
+  * Added Matrix#each_row / Matrix#each_column (which pass row and column matrices to the block)
+  * Added Matrix#row_vecview / Matrix#column_vecview (construct a row and column Matrix::View)
+  * Added Matrix#each_vec_row / Matrix#each_vec_column (same as the previous ones, but the block will receive a Vector::View instead)
+  * Added x, y, z and w accessors for Vector (this will probably go into Vector2, Vector3 and Vector4 in the future)
+  * "negate" operator
+  * Documentation is now YARD based. This will significantly improve the documentation readability.
+  * Added Vector#map_index! and Vector#wrap!
+  * Initial support for Random Number Generators (only Uniform and Gaussian distributions for the moment)
+  * Added Vector#<, #>, #<= and #>=
+  * Added Matrix#map_with_index!
+  * No more #fast_each and stuff. Now #each IS fast. This is accomplished by writing actual Ruby-C code instead of using FFI for
+    these functions.
+  * Initial support for GSL's special functions
+
+=== 0.2.1
+* Fixed for FFI 0.6.0
+
+=== 0.2.0
+* Completed Vector
+* Added Matrix (mostly complete)
+* Added Vector::View and Matrix::View
+
+=== 0.1.0 / 2009-12-09
+
+* Initial version
+  * Only class Vector (but completely documented and implemented)
+

data/Manifest

@@ -0,0 +1,33 @@
+History.txt
+Manifest
+README.rdoc
+Rakefile
+ext/extconf.rb
+ext/gslng_extensions.cpp
+ext/plotting.cpp
+lib/core_extensions/array.rb
+lib/gslng.rb
+lib/gslng/backend.rb
+lib/gslng/backend_components/error_handling.rb
+lib/gslng/backend_components/matrix.rb
+lib/gslng/backend_components/rng.rb
+lib/gslng/backend_components/special.rb
+lib/gslng/backend_components/stats.rb
+lib/gslng/backend_components/vector.rb
+lib/gslng/matrix.rb
+lib/gslng/matrix_view.rb
+lib/gslng/plotter.rb
+lib/gslng/rng/gaussian.rb
+lib/gslng/rng/rng.rb
+lib/gslng/rng/uniform.rb
+lib/gslng/special.rb
+lib/gslng/vector.rb
+lib/gslng/vector_view.rb
+ruby-gsl-ng.gemspec
+test/benchmark.rb
+test/benchmark_results
+test/matrix_test.rb
+test/rng_test.rb
+test/test_gsl.rb
+test/test_special.rb
+test/vector_test.rb

data/README.rdoc

@@ -0,0 +1,14 @@
+= Ruby/GSL-ng
+
+* http://wiki.github.com/v01d/ruby-gsl-ng/
+
+== DESCRIPTION:
+
+* Note: This fork has a fix to a memory leak.  Making a separate gem until that's pulled to the master repo.
+
+New-generation Ruby/GSL wrapper.
+
+
+== LICENSE:
+
+GPLv2

data/Rakefile

@@ -0,0 +1,27 @@
+# -*- ruby -*-
+require "bundler/gem_tasks"
+
+__END__
+require 'rubygems'
+require 'rake'
+require 'echoe'
+require 'yard'
+
+Echoe.new('ruby-gsl-ng') do |p|
+  p.author = 'v01d'
+  p.summary = "Ruby/GSL new-generation wrapper"
+  p.url = "http://github.com/v01d/ruby-gsl-ng"
+  p.version = "0.2.6"
+  p.dependencies = ['yard', 'ffi']
+#  p.eval = proc { s.has_rdoc = 'yard' }
+end
+
+Rake::TaskManager.class_eval do
+  def remove_task(task)
+    @tasks.delete(task.to_s)
+  end
+end
+
+Rake.application.remove_task(:docs)
+YARD::Rake::YardocTask.new(:docs) {|t| t.options = ['--verbose','--no-private','--hide-void']}
+

data/ext/extconf.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/ruby
+require 'mkmf'
+
+extra_flags='-O4 -DHAVE_INLINE=1'
+
+## Check for GSL
+find_executable('pkg-config') or raise 'pkg-config should be installed'
+gsl_vars = pkg_config('gsl') or raise 'GSL not found!'
+
+# Configuration
+if (RUBY_VERSION =~ /^1\.8/) then $libs << ' -lstdc++' end # Seems necessary in some cases
+
+## Create Makefile
+with_cppflags("#{extra_flags}") { true }
+with_cflags('') { true }
+CONFIG['CXXFLAGS']=''
+
+create_makefile('gslng_extensions')
+
+

data/ext/gslng_extensions.cpp

@@ -0,0 +1,307 @@
+/**
+ * gsl_extension module: provides some simple C functions in cases where a faster version of some
+ * Ruby method is really necessary.
+ * This could actually a standard C library (not a Ruby extension), but it's easier this way.
+ */
+
+#include <ruby.h>
+#include <gsl/gsl_vector.h>
+#include <gsl/gsl_matrix.h>
+#include <iostream>
+using namespace std;
+
+/************************* Vector functions *****************************/
+
+static VALUE gsl_vector_map(VALUE self, VALUE ptr) {
+	gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
+	for (size_t i = 0; i < v->size; i++)
+		gsl_vector_set(v, i, NUM2DBL(rb_yield(rb_float_new(gsl_vector_get(v, i)))));
+	
+	return self;
+}
+
+static VALUE gsl_vector_map_index(VALUE self, VALUE ptr) {
+	gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
+	for (size_t i = 0; i < v->size; i++) {
+		VALUE vi = ULONG2NUM(i);
+		gsl_vector_set(v, i, NUM2DBL(rb_yield(vi)));
+	}
+	
+	return self;
+}
+
+static VALUE gsl_vector_each_with_index(VALUE self, VALUE ptr) {
+	gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
+	for (size_t i = 0; i < v->size; i++) {
+		VALUE vi = ULONG2NUM(i);
+		rb_yield_values(2, rb_float_new(gsl_vector_get(v, i)), vi);
+	}
+	
+	return self;
+}
+
+static VALUE gsl_vector_each(VALUE self, VALUE ptr) {
+	gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
+	for (size_t i = 0; i < v->size; i++)
+		rb_yield(rb_float_new(gsl_vector_get(v, i)));
+	
+	return self;
+}
+
+static VALUE gsl_vector_to_a(VALUE self, VALUE ptr) {
+	gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
+	
+	VALUE array = rb_ary_new2(v->size);
+	for (size_t i = 0; i < v->size; i++)
+		rb_ary_store(array, i, rb_float_new(gsl_vector_get(v, i)));
+	
+	return array;
+}
+
+static VALUE gsl_vector_from_array(VALUE self, VALUE ptr, VALUE array) {
+	gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
+	if (v->size != RARRAY_LEN(array)) rb_raise(rb_eRuntimeError, "Sizes differ!");
+	
+	for (size_t i = 0; i < v->size; i++)
+		gsl_vector_set(v, i, NUM2DBL(rb_ary_entry(array, i)));
+	
+	return self;
+}
+
+static VALUE gsl_vector_get_operator(VALUE self, VALUE ptr, VALUE element) {
+  gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
+  long i = FIX2LONG(element);
+  if (i < 0) { i = v->size + i; }
+  return rb_float_new(gsl_vector_get(v, (size_t)i));
+}
+
+static VALUE gsl_vector_set_operator(VALUE self, VALUE ptr, VALUE element, VALUE value) {
+  gsl_vector* v = (gsl_vector*)NUM2ULONG(ptr);
+  long i = FIX2LONG(element);
+  if (i < 0) { i = v->size + i; }
+  gsl_vector_set(v, (size_t)i, NUM2DBL(value));
+  return Qnil;
+}
+
+static VALUE gsl_vector_eql(VALUE self, VALUE ptr, VALUE other_ptr) {
+  gsl_vector* v1 = (gsl_vector*)NUM2ULONG(ptr);
+  gsl_vector* v2 = (gsl_vector*)NUM2ULONG(other_ptr);
+  if (v1->size != v2->size) return Qfalse;
+  for (size_t i = 0; i < v1->size; i++) {
+    if (gsl_vector_get(v1, i) != gsl_vector_get(v2, i)) return Qfalse;
+  }
+  return Qtrue;
+}
+
+// Hide the view in a new vector (gsl_vector_subvector)
+extern "C" gsl_vector* gsl_vector_subvector_with_stride2(gsl_vector* v, size_t offset, size_t stride, size_t n) {
+  gsl_vector_view view = gsl_vector_subvector_with_stride(v, offset, stride, n);
+  gsl_vector* vector_view = (gsl_vector*) malloc(sizeof(gsl_vector));
+  *vector_view = view.vector;
+  return vector_view;
+}
+
+// Hide the view in a new vector (gsl_vector_subvector)
+extern "C" gsl_vector* gsl_vector_subvector2(gsl_vector* v, size_t offset, size_t n) {
+  gsl_vector_view view = gsl_vector_subvector(v, offset, n);
+  gsl_vector* vector_view = (gsl_vector*) malloc(sizeof(gsl_vector));
+  *vector_view = view.vector;
+  return vector_view;
+}
+
+extern "C" double* gsl_vector_as_array(gsl_vector* v) {
+	return v->data;
+}
+
+/************************* Matrix functions *****************************/
+
+static VALUE gsl_matrix_map(VALUE self, VALUE ptr) {
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
+  size_t size1 = m->size1;
+  size_t size2 = m->size2;
+
+	for (size_t i = 0; i < size1; i++)
+    for (size_t j = 0; j < size2; j++)
+      gsl_matrix_set(m, i, j, NUM2DBL(rb_yield(rb_float_new(gsl_matrix_get(m, i, j)))));
+
+  return self;
+}
+
+static VALUE gsl_matrix_map_array(VALUE self, VALUE ptr) {
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
+
+	VALUE array = rb_ary_new2(m->size1);
+	for (size_t i = 0; i < m->size1; i++) {
+    VALUE row = rb_ary_new2(m->size2);
+    for (size_t j = 0; j < m->size2; j++) {
+      rb_ary_store(row, j, rb_yield(rb_float_new(gsl_matrix_get(m, i, j))));
+    }
+    rb_ary_store(array, i, row);
+  }
+
+	return array;
+}
+
+static VALUE gsl_matrix_map_index(VALUE self, VALUE ptr) {
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
+  size_t size1 = m->size1;
+  size_t size2 = m->size2;
+
+	for (size_t i = 0; i < size1; i++)
+    for (size_t j = 0; j < size2; j++)
+      gsl_matrix_set(m, i, j, NUM2DBL(rb_yield_values(2, ULONG2NUM(i), ULONG2NUM(j))));
+
+  return self;
+}
+
+static VALUE gsl_matrix_map_with_index(VALUE self, VALUE ptr) {
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
+  size_t size1 = m->size1;
+  size_t size2 = m->size2;
+
+	for (size_t i = 0; i < size1; i++)
+    for (size_t j = 0; j < size2; j++)
+      gsl_matrix_set(m, i, j, NUM2DBL(rb_yield_values(3, rb_float_new(gsl_matrix_get(m, i, j)), ULONG2NUM(i), ULONG2NUM(j))));
+
+  return self;
+}
+
+static VALUE gsl_matrix_each(VALUE self, VALUE ptr) {
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
+  size_t size1 = m->size1;
+  size_t size2 = m->size2;
+
+	for (size_t i = 0; i < size1; i++)
+    for (size_t j = 0; j < size2; j++)
+      rb_yield(rb_float_new(gsl_matrix_get(m, i, j)));
+
+  return self;
+}
+
+static VALUE gsl_matrix_each_with_index(VALUE self, VALUE ptr) {
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
+  size_t size1 = m->size1;
+  size_t size2 = m->size2;
+
+	for (size_t i = 0; i < size1; i++) {
+    VALUE vi = ULONG2NUM(i);
+    for (size_t j = 0; j < size2; j++)
+      rb_yield_values(3, rb_float_new(gsl_matrix_get(m, i, j)), vi, ULONG2NUM(j));
+  }
+  
+  return self;
+}
+
+static VALUE gsl_matrix_to_a(VALUE self, VALUE ptr) {
+	gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
+
+	VALUE array = rb_ary_new2(m->size1);
+	for (size_t i = 0; i < m->size1; i++) {
+    VALUE row = rb_ary_new2(m->size2);
+    for (size_t j = 0; j < m->size2; j++) {
+      rb_ary_store(row, j, rb_float_new(gsl_matrix_get(m, i, j)));
+    }
+    rb_ary_store(array, i, row);
+  }
+
+	return array;
+}
+
+static VALUE gsl_matrix_from_array(VALUE self, VALUE ptr, VALUE array) {
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
+  if (m->size1 != RARRAY_LEN(array)) rb_raise(rb_eRuntimeError, "Sizes differ!");
+
+	for (size_t i = 0; i < m->size1; i++) {
+    VALUE row = rb_ary_entry(array, i);
+    if (m->size2 != RARRAY_LEN(row)) rb_raise(rb_eRuntimeError, "Sizes differ!");
+
+    for (size_t j = 0; j < m->size2; j++)
+      gsl_matrix_set(m, i, j, NUM2DBL(rb_ary_entry(row, j)));
+  }
+
+	return self;
+}
+
+static VALUE gsl_matrix_get_operator(VALUE self, VALUE ptr, VALUE element_i, VALUE element_j) {
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
+  size_t i = NUM2ULONG(element_i);
+  size_t j = NUM2ULONG(element_j);
+  return rb_float_new(gsl_matrix_get(m, i, j));
+}
+
+static VALUE gsl_matrix_set_operator(VALUE self, VALUE ptr, VALUE element_i, VALUE element_j, VALUE value) {
+  gsl_matrix* m = (gsl_matrix*)NUM2ULONG(ptr);
+  size_t i = NUM2ULONG(element_i);
+  size_t j = NUM2ULONG(element_j);
+  gsl_matrix_set(m, i, j, NUM2DBL(value));
+  return Qnil;
+}
+
+// Hide the view in a new matrix (gsl_matrix_submatrix)
+extern "C" gsl_matrix* gsl_matrix_submatrix2(gsl_matrix* m_ptr, size_t x, size_t y, size_t n, size_t m) {
+  gsl_matrix_view view = gsl_matrix_submatrix(m_ptr, x, y, n, m);
+  gsl_matrix* matrix_view = (gsl_matrix*) malloc(sizeof(gsl_matrix));
+  *matrix_view = view.matrix;
+  return matrix_view;
+}
+
+extern "C" gsl_vector* gsl_matrix_row_view(gsl_matrix* m_ptr, size_t row, size_t offset, size_t size) {
+  gsl_vector_view view = gsl_matrix_subrow(m_ptr, row, offset, size);
+  gsl_vector* vector_view = (gsl_vector*) malloc(sizeof(gsl_vector));
+  *vector_view = view.vector;
+  return vector_view;
+}
+
+extern "C" gsl_vector* gsl_matrix_column_view(gsl_matrix* m_ptr, size_t column, size_t offset, size_t size) {
+  gsl_vector_view view = gsl_matrix_subcolumn(m_ptr, column, offset, size);
+  gsl_vector* vector_view = (gsl_vector*) malloc(sizeof(gsl_vector));
+  *vector_view = view.vector;
+  return vector_view;
+}
+
+extern "C" void gsl_matrix_slide(gsl_matrix* m, ssize_t slide_i, ssize_t slide_j)
+{
+  gsl_matrix* m2 = gsl_matrix_calloc(m->size1, m->size2);
+
+  for (ssize_t i = 0; (size_t)i < m->size1; i++) {
+    for (ssize_t j = 0; (size_t)j < m->size2; j++) {
+      if (i - slide_i >= 0 && (size_t)(i - slide_i) < m->size1 && j - slide_j >= 0 && (size_t)(j - slide_j) < m->size2) {
+        double v = gsl_matrix_get(m, (size_t)(i - slide_i), (size_t)(j - slide_j));
+        gsl_matrix_set(m2, (size_t)i, (size_t)j, v);
+      }            
+    }
+  }
+
+  gsl_matrix_memcpy(m, m2);
+  gsl_matrix_free(m2);
+}
+
+/************************* Module initialization *****************************/
+
+extern "C" void Init_gslng_extensions(void) {
+	VALUE GSLng_module = rb_define_module("GSLng");
+	VALUE Backend_module = rb_funcall(GSLng_module, rb_intern("backend"), 0);
+
+	// vector
+  rb_define_module_function(Backend_module, "gsl_vector_get_operator", (VALUE(*)(ANYARGS))gsl_vector_get_operator, 2);
+  rb_define_module_function(Backend_module, "gsl_vector_set_operator", (VALUE(*)(ANYARGS))gsl_vector_set_operator, 3);
+	rb_define_module_function(Backend_module, "gsl_vector_map!", (VALUE(*)(ANYARGS))gsl_vector_map, 1);
+	rb_define_module_function(Backend_module, "gsl_vector_map_index!", (VALUE(*)(ANYARGS))gsl_vector_map_index, 1);
+	rb_define_module_function(Backend_module, "gsl_vector_each_with_index", (VALUE(*)(ANYARGS))gsl_vector_each_with_index, 1);
+	rb_define_module_function(Backend_module, "gsl_vector_each", (VALUE(*)(ANYARGS))gsl_vector_each, 1);
+	rb_define_module_function(Backend_module, "gsl_vector_to_a", (VALUE(*)(ANYARGS))gsl_vector_to_a, 1);
+	rb_define_module_function(Backend_module, "gsl_vector_from_array", (VALUE(*)(ANYARGS))gsl_vector_from_array, 2);
+  rb_define_module_function(Backend_module, "gsl_vector_eql?", (VALUE(*)(ANYARGS))gsl_vector_eql, 2);
+
+  // matrix
+	rb_define_module_function(Backend_module, "gsl_matrix_map!", (VALUE(*)(ANYARGS))gsl_matrix_map, 1);
+  rb_define_module_function(Backend_module, "gsl_matrix_map_array", (VALUE(*)(ANYARGS))gsl_matrix_map_array, 1);
+	rb_define_module_function(Backend_module, "gsl_matrix_map_index!", (VALUE(*)(ANYARGS))gsl_matrix_map_index, 1);
+  rb_define_module_function(Backend_module, "gsl_matrix_map_with_index!", (VALUE(*)(ANYARGS))gsl_matrix_map_with_index, 1);
+	rb_define_module_function(Backend_module, "gsl_matrix_each_with_index", (VALUE(*)(ANYARGS))gsl_matrix_each_with_index, 1);
+	rb_define_module_function(Backend_module, "gsl_matrix_each", (VALUE(*)(ANYARGS))gsl_matrix_each, 1);
+	rb_define_module_function(Backend_module, "gsl_matrix_to_a", (VALUE(*)(ANYARGS))gsl_matrix_to_a, 1);
+	rb_define_module_function(Backend_module, "gsl_matrix_from_array", (VALUE(*)(ANYARGS))gsl_matrix_from_array, 2);
+  rb_define_module_function(Backend_module, "gsl_matrix_get_operator", (VALUE(*)(ANYARGS))gsl_matrix_get_operator, 3);
+  rb_define_module_function(Backend_module, "gsl_matrix_set_operator", (VALUE(*)(ANYARGS))gsl_matrix_set_operator, 4);
+}