redshift 1.3.24 → 1.3.26

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6efe4898ea37d2d69e2bf76b09c1a8f21a49f5e1
+  data.tar.gz: f49ba364d83aeab669be50e244c09a49499e600c
+SHA512:
+  metadata.gz: 6116140716bae7b6b7555d714aac7d3f3d7f62c04583f1da0128c17303449fc254342ad7857757ae65503bae44f96df031054c176dd7a4a7307b5c164a90653c
+  data.tar.gz: 442f564bc09f72a30b8914e8e32b5bb124fee97b0abffb50f932001c1c0ed011e3d1ceb6304817861f1c7de8e7bca84187aac23ea64048d8b6310c556e57aac3

data/{README → README.md}

@@ -1,25 +1,25 @@
-= RedShift
+# RedShift #
 
 A framework for simulation of networks of hybrid automata, similar to SHIFT and Lambda-SHIFT. Includes ruby-based DSL for defining simulation components, and ruby/C code generation and runtime.
 
-There's no documentation yet, but it will be at http://redshift.sourceforge.net and http://redshift.rubyforge.org. For now, start with the examples.
+There's no documentation yet. For now, start with the examples.
 
-== Requirements
+## Requirements ##
 
 RedShift needs ruby 1.8.x and a compatible C compiler. If you can build native gems, you're all set.
 
 Some of the examples also use Ruby/Tk and the tkar gem.
 
-== Env vars
+## Env vars ##
 
 If you have a multicore system and are using the gnu toolchain, set
 
-REDSHIFT_MAKE_ARGS='-j -l2'
+    REDSHIFT_MAKE_ARGS='-j -l2'
 
 or some variation. You'll find that rebuilds of your simulation code go faster.
 
 ----
 
-Copyright (C) 2001-2010, Joel VanderWerf, vjoel@users.sourceforge.net
+Copyright (C) 2001-2013, Joel VanderWerf, mailto:vjoel@users.sourceforge.net
 Distributed under the Ruby license. See www.ruby-lang.org.
 

data/RELEASE-NOTES

@@ -1,3 +1,17 @@
+redshift 1.3.26
+
+- updated to ruby 2.0
+
+- fixed gemspec
+
+redshift 1.3.25
+
+- added DVectorFloat
+
+- added 'rake ex' task to build extensions for current ruby version
+
+- minor bug fixes and updates
+
 redshift 1.3.24
 
 - fixed include path problem when running from installed gem

data/bench/bench

@@ -9,7 +9,7 @@ def bench_one(name)
     puts "#{name}:"
     #{name.split(/[-_]/).map {|w|w.capitalize}.join}.do_bench {|l| puts l}
   }
-  ruby = Config::CONFIG["RUBY_INSTALL_NAME"]
+  ruby = RbConfig::CONFIG["RUBY_INSTALL_NAME"]
   system ruby, "-r" , "./bench", "-r", lib, "-e", cmd
 end
 

data/ext/redshift/dvector-float/dvector-float.c

@@ -0,0 +1,183 @@
+#include "dvector-float.h"
+#include <math.h>
+
+static VALUE dvf_alloc(VALUE klass)
+{
+    VALUE self;
+    RS_DVectorFloat *dvf;
+    
+    self = Data_Make_Struct(klass, RS_DVectorFloat, 0, -1, dvf);
+
+    dvf->len = 0;
+    dvf->capa = 0;
+    dvf->ptr = 0;
+    
+    return self;
+}
+
+void rs_dvf_grow(RS_DVectorFloat *dvf)
+{
+    if (!dvf->ptr) {
+        dvf->capa = 16;
+        dvf->ptr = ALLOC_N(float, dvf->capa);
+    }
+    else if (dvf->len == dvf->capa) {
+        dvf->capa *= 2;
+        REALLOC_N(dvf->ptr, float, dvf->capa);
+    }
+}
+
+void rs_dvf_shrink(RS_DVectorFloat *dvf)
+{
+    if (dvf->ptr && dvf->len < dvf->capa) {
+        REALLOC_N(dvf->ptr, float, dvf->len);
+        dvf->capa = dvf->len;
+    }
+}
+
+static VALUE dvf_method_push(int argc, VALUE *argv, VALUE self)
+{
+    int i;
+    RS_DVectorFloat *dvf;
+    
+    Data_Get_Struct(self, RS_DVectorFloat, dvf);
+    
+    for (i = 0; i < argc; i++) {
+        rs_dvf_push(dvf, NUM2DBL(argv[i]));
+    }
+
+    return self;
+}
+
+static VALUE dvf_method_pop(VALUE self)
+{
+    RS_DVectorFloat *dvf;
+    
+    Data_Get_Struct(self, RS_DVectorFloat, dvf);
+
+    return dvf->len == 0 ? Qnil : rb_float_new(rs_dvf_pop(dvf));
+}
+
+static VALUE dvf_method_each(VALUE self)
+{
+    long i;
+    RS_DVectorFloat *dvf;
+    
+    Data_Get_Struct(self, RS_DVectorFloat, dvf);
+
+    RETURN_ENUMERATOR(self, 0, 0);
+    for (i=0; i < dvf->len; i++) {
+	rb_yield(rb_float_new(dvf->ptr[i]));
+    }
+    
+    return self;
+}
+
+static VALUE dvf_method_to_a(VALUE self)
+{
+    int i;
+    RS_DVectorFloat *dvf;
+    VALUE ary;
+    
+    Data_Get_Struct(self, RS_DVectorFloat, dvf);
+
+    ary = rb_ary_new();
+    if (!dvf->ptr) return ary;
+
+    for (i=0; i < dvf->len; i++) {
+	rb_ary_push(ary, rb_float_new(dvf->ptr[i]));
+    }
+    
+    return ary;
+}
+
+static VALUE dvf_method_length(VALUE self)
+{
+    RS_DVectorFloat *dvf;
+    Data_Get_Struct(self, RS_DVectorFloat, dvf);
+    return INT2NUM(dvf->len);
+}
+
+static VALUE dvf_method_equal(VALUE self, VALUE other)
+{
+    int i;
+    RS_DVectorFloat *dvf1, *dvf2;
+
+    if (self == other) return Qtrue;
+    if (CLASS_OF(self) != CLASS_OF(other)) return Qfalse;
+
+    Data_Get_Struct(self, RS_DVectorFloat, dvf1);
+    Data_Get_Struct(other, RS_DVectorFloat, dvf2);
+    if (dvf1->len != dvf2->len) return Qfalse;
+
+    for (i=0; i < dvf1->len; i++) {
+        if (dvf1->ptr[i] != dvf2->ptr[i]) return Qfalse;
+    }
+    return Qtrue;
+}
+
+static VALUE dvf_method_hash(VALUE self)
+{
+    long i, h;
+    RS_DVectorFloat *dvf;
+
+    Data_Get_Struct(self, RS_DVectorFloat, dvf);
+
+    h = dvf->len;
+    for (i=0; i < dvf->len; i++) {
+        int hash, j;
+        char *c;
+        float f;
+        
+	h = (h << 1) | (h<0 ? 1 : 0);
+        f = dvf->ptr[i];
+
+        if (f == 0) f = fabs(f);
+        c = (char*)&f;
+        for (hash=0, j=0; j<sizeof(float); j++) {
+	    hash = (hash * 971) ^ (unsigned char)c[j];
+        }
+        if (hash < 0) hash = -hash;
+
+	h ^= hash;
+    }
+    return LONG2FIX(h);
+}
+
+static VALUE dvf_method_load_data(VALUE self, VALUE from_array)
+{
+    long i;
+    RS_DVectorFloat *dvf;
+    Data_Get_Struct(self, RS_DVectorFloat, dvf);
+
+    for (i=0; i < RARRAY_LEN(from_array); i++) {
+        rs_dvf_push(dvf, NUM2DBL(RARRAY_PTR(from_array)[i]));
+    }
+    
+    return self;
+}
+
+VALUE rs_cDVectorFloat;
+
+void
+Init_dvector_float(void)
+{
+    rs_cDVectorFloat = rb_path2class("RedShift::DVectorFloat");
+
+    rb_define_alloc_func(rs_cDVectorFloat, dvf_alloc);
+    rb_define_method(rs_cDVectorFloat, "push", dvf_method_push, -1);
+    rb_define_method(rs_cDVectorFloat, "pop", dvf_method_pop, 0);
+    rb_define_alias(rs_cDVectorFloat,  "<<", "push");
+
+    rb_define_method(rs_cDVectorFloat, "each", dvf_method_each, 0);
+    rb_define_method(rs_cDVectorFloat, "to_a", dvf_method_to_a, 0);
+    rb_define_method(rs_cDVectorFloat, "length", dvf_method_length, 0);
+    rb_define_alias(rs_cDVectorFloat,  "size", "length");
+
+    rb_define_method(rs_cDVectorFloat, "==", dvf_method_equal, 1);
+    rb_define_method(rs_cDVectorFloat, "eql?", dvf_method_equal, 1);
+    rb_define_method(rs_cDVectorFloat, "hash", dvf_method_hash, 0);
+
+    rb_define_method(rs_cDVectorFloat, "_load_data", dvf_method_load_data, 1);
+    rb_define_method(rs_cDVectorFloat, "_dump_data", dvf_method_to_a, 0);
+}

data/ext/redshift/dvector-float/dvector-float.h

@@ -0,0 +1,36 @@
+#ifndef dvector_float_h
+#define dvector_float_h
+
+#include <ruby.h>
+
+typedef struct {
+  long    len;
+  long    capa;
+  float  *ptr;
+} RS_DVectorFloat;
+
+extern void rs_dvf_grow(RS_DVectorFloat *dvf);
+extern void rs_dvf_shrink(RS_DVectorFloat *dvf);
+
+inline static RS_DVectorFloat *rs_dvf(VALUE obj)
+{
+    return (RS_DVectorFloat *)DATA_PTR(obj);
+}
+
+inline static void rs_dvf_push(RS_DVectorFloat *dvf, float val)
+{
+    if (dvf->len == dvf->capa) {
+        rs_dvf_grow(dvf);
+    }
+    dvf->ptr[dvf->len++] = val;
+}
+
+inline static float rs_dvf_pop(RS_DVectorFloat *dvf)
+{
+    if (dvf->len == 0) {
+        return 0;
+    }
+    return dvf->ptr[--dvf->len];
+}
+
+#endif

data/ext/redshift/dvector-float/dvector-float.rb

@@ -0,0 +1,33 @@
+module RedShift; end
+
+# A linear collection of single-precision floats.
+#
+# Intended primarily for access from C code, using the inline
+# rs_dvf_push() and rs_dvf_pop() functions.
+#
+# Implements some of the same methods as Array, but not all.
+#
+# Like an Array, a DVector grows implicitly as elements are
+# pushed. But unlike an Array, a DVector shrinks only explicitly.
+# This is to minimize realloc() calls when a DVector rapidly
+# grows and shrinks.
+
+class RedShift::DVectorFloat
+  include Enumerable
+  require 'redshift/dvector-float/dvector_float.so'
+  
+  def self.[](*elts)
+    new elts
+  end
+  
+  def initialize(elts=nil)
+    push(*elts) if elts
+  end
+  
+  def inspect; to_a.inspect; end
+  def to_s; to_a.to_s; end
+  
+  def dup
+    self.class.new to_a
+  end
+end

data/ext/redshift/dvector-float/extconf.rb

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

data/lib/redshift/redshift.rb

@@ -70,7 +70,7 @@ end
 module RedShift
   include Math
   
-  VERSION = '1.3.24'
+  VERSION = '1.3.25'
 
   Infinity = Math::Infinity
 

data/lib/redshift/target/c/world-gen.rb

@@ -1294,7 +1294,8 @@ class World
 
   hook = /\bhook_\w+/
   world_classes = World.subclasses + [World]
-  hooks = Hash.new {|h,cl| h[cl] = cl.instance_methods(true).grep(hook).sort}
+  hooks = Hash.new {|h,cl| h[cl] =
+    cl.instance_methods(true).grep(hook).sort.map{|s|s.to_sym} }
   hooks[World.superclass] = nil
   known_hooks = nil
   

data/test/test.rb

@@ -37,7 +37,7 @@ tests.sort!
 #end
 
 require 'rbconfig'
-ruby = Config::CONFIG["RUBY_INSTALL_NAME"]
+ruby = RbConfig::CONFIG["RUBY_INSTALL_NAME"]
 
 pending = tests.dup
 failed = []

data/test/test_dvector-float.rb

@@ -0,0 +1,113 @@
+require 'redshift/dvector-float/dvector-float'
+require 'test/unit'
+
+DVectorFloat = RedShift::DVectorFloat
+
+class TestDVectorFloat < Test::Unit::TestCase
+  def make_dvs n
+    assert_nothing_thrown do
+      n.times do
+        DVectorFloat.new
+      end
+    end
+  end
+
+  def test_gc
+    GC.start
+    n = ObjectSpace.each_object(DVectorFloat){}
+
+    assert_nothing_thrown do
+      make_dvs 100
+    end
+    
+    GC.start
+    n2 = ObjectSpace.each_object(DVectorFloat){}
+
+    assert((0..n+1) === n2, "Not in #{0}..#{n+1}: #{n2}")
+  end
+  
+  def test_gc_stress
+    GC.stress = true
+    assert_nothing_thrown do
+      make_dvs 10
+    end
+  ensure
+    GC.stress = false
+  end
+  
+  def test_push_pop
+    dv = DVectorFloat.new
+    assert_nothing_thrown do
+      dv.push(1)
+      dv.push(2.567)
+      dv.push(3)
+    end
+    assert_equal(3, dv.pop)
+    assert_in_delta(2.567, dv.pop, 0.01)
+    assert_equal(1, dv.pop)
+    assert_equal(nil, dv.pop)
+  end
+  
+  def test_each
+    dv = DVectorFloat[1, 2.567, 3]
+    a = []
+    dv.each do |x|
+      a << x
+    end
+    [1,2.567,3].zip a do |x,y|
+      assert_in_delta(x, y, 0.01)
+    end
+  end
+  
+  def test_to_a
+    dv = DVectorFloat[1, 2.567, 3]
+    [1,2.567,3].zip dv.to_a do |x,y|
+      assert_in_delta(x, y, 0.01)
+    end
+  end
+  
+  def test_length
+    dv = DVectorFloat[1, 2.567, 3]
+    assert_equal(3, dv.length)
+    dv = DVectorFloat.new
+    assert_equal(0, dv.length)
+  end
+  
+  def test_equal
+    dv1 = DVectorFloat[1, 2.567, 3]
+    dv2 = DVectorFloat[1, 2.567, 3, 4]
+    assert_equal(false, dv1 == dv2)
+    assert_equal(false, dv1 == [1,2.567,3])
+    assert_equal(false, dv1 == 123)
+    assert_equal(true, dv1 == dv1)
+    assert_equal(true, DVectorFloat.new == DVectorFloat.new)
+    assert_equal(true, DVectorFloat[1] == DVectorFloat[1.0])
+  end
+  
+  def test_eql
+    dv1 = DVectorFloat[1, 2.567, 3]
+    dv2 = DVectorFloat[1, 2.567, 3, 4]
+    assert_equal(false, dv1.eql?(dv2))
+    assert_equal(false, dv1.eql?([1,2.567,3]))
+    assert_equal(false, dv1.eql?(123))
+    assert_equal(true, dv1.eql?(dv1))
+    assert_equal(true, DVectorFloat.new.eql?(DVectorFloat.new))
+  end
+  
+  def test_hash
+    h = {}
+    h[DVectorFloat[1,2.567,3]] = true
+    assert_equal(true, h[DVectorFloat[1,2.567,3]])
+    assert_equal(nil, h[DVectorFloat[1,2.567,3,4]])
+  end
+  
+  def test_dup
+    DVectorFloat[1,2.567,3] == DVectorFloat[1,2.567,3].dup
+  end
+  
+  def test_marshal
+    dv = DVectorFloat[1, 2.567, 3]
+    dv2 = Marshal.load(Marshal.dump(dv))
+    assert_equal(dv.to_a, dv2.to_a)
+  end
+end