redshift 1.3.24 → 1.3.30

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0e70ddb9e9f05b61a7b15acd4a9a59ad94f8fb43771aa0619f0d69400f691ba2
+  data.tar.gz: 0a2087fa620759313761ddcfc788dc44fcc204f5b0d2d8ceb5e73681102c2f75
+SHA512:
+  metadata.gz: '059c869b96c8e837ebdd1762e28859f5fdf6d4f4f76afa6a955149a93013b11d262d849b30e472523ce9ca9d09f0b255efc6ae64bcf9488703a0431e6af5cbe5'
+  data.tar.gz: 25438a65be067f8b8a5df3dbd9f276722e2de0468bfa06273041fd7dc3e56f79677a1382c75633783c4d46c436845df1873ec34b72c89d83beb87be1638c814a

data/README.md

@@ -0,0 +1,49 @@
+# 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.
+
+RedShift is for simulating digital devices operating in an analog world. It's also for simulating any system that exhibits a mix of discrete and continuous behavior.
+
+There's not much [documentation](doc) yet, but plenty of [examples](examples). Some of the original SHIFT papers are available: [Shift: A Formalism and a Programming Language for Dynamic Networks of Hybrid Automata]( http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.32.5913&rep=rep1&type=pdf).
+
+My [2009 rubyconf talk](http://confreaks.com/videos/165-rubyconf2009-dsls-code-generation-and-new-domains-for-ruby) discusses RedShift.
+
+## Requirements ##
+
+RedShift needs ruby (1.8, 1.9, 2.0, 2.1) 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.
+
+## Installation ##
+
+Install as gem:
+
+    gem install redshift
+
+## Env vars ##
+
+If you have a multicore system and are using the gnu toolchain, set
+
+    REDSHIFT_MAKE_ARGS='-j -l2'
+
+or some variation. You'll find that rebuilds of your simulation code go faster.
+
+
+What is RedShift?
+-----------------
+
+RedShift combines *dataflow* programming (for continuous variables) with *actor*-based programming (for discrete events, states, and variables, and also for continuous variables).
+
+Examples
+--------
+
+See the [examples](examples) dir.
+
+The [RedCloud](https://github.com/vjoel/redcloud) project is based on RedShift.
+
+
+----
+
+Copyright (C) 2001-2014, Joel VanderWerf, mailto:vjoel@users.sourceforge.net
+Distributed under the Ruby license. See www.ruby-lang.org.
+

data/RELEASE-NOTES

@@ -1,3 +1,34 @@
+redshift 1.3.28
+
+- gemspec specifies dvector-float extension
+
+redshift 1.3.28
+
+- update .gitignore
+- fixes for ruby 2.1
+- modernize rakefile: release tasks
+- use -march=native in formula benchmark
+
+redshift 1.3.27
+
+- cleanup
+- use minitest
+- remove local isaac ext and depend on prng-isaac gem instead
+
+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
@@ -7,7 +38,7 @@ redshift 1.3.23
 - compatible with ruby-1.9.2
 
 - renamed Random module to RandomDistribution to avoid conflict
-    
+
 redshift 1.3.22
 
 - handling of env vars is more consistent
@@ -100,7 +131,7 @@ redshift 1.3.13
 
 redshift 1.3.12
 
-- Fixed bug with explicitly assigning an array to a 
+- Fixed bug with explicitly assigning an array to a
   delay buffer.
 
 - Raise if time_step changes while using delay.
@@ -185,7 +216,7 @@ redshift 1.2.41
 - Improved message for reset type error.
 
 - Link vars can now be declared without a type (defaults to Component).
- 
+
 - Fixed Queue behavior when #unpop called with SimultaneousQueueEntries.
 
 - Added examples and tests.

data/Rakefile

@@ -0,0 +1,81 @@
+require 'rake'
+
+PRJ = "redshift"
+
+def cur_ruby
+  require 'rbconfig'
+  @cur_ruby ||= RbConfig::CONFIG["RUBY_INSTALL_NAME"]
+end
+
+def version
+  @version ||= begin
+    require 'redshift/redshift'
+    warn "RedShift::VERSION not a string" unless
+      RedShift::VERSION.kind_of? String
+    RedShift::VERSION
+  end
+end
+
+def tag
+  @tag ||= "#{PRJ}-#{version}"
+end
+
+desc "Run unit tests"
+task :test do |t|
+  sh "cd test && RUBYLIB=../lib:../ext:$RUBYLIB ./test.rb"
+end
+
+desc "build extensions for current ruby: #{RUBY_VERSION}"
+task :build_ext do
+  require 'find'
+  Find.find('ext/redshift') do |f|
+    next unless File.basename(f) == "extconf.rb"
+    d = File.dirname(f)
+    Dir.chdir d do
+      sh "make distclean || true"
+      ruby "extconf.rb"
+      sh "make"
+    end
+  end
+end
+
+desc "Commit, tag, and push repo; build and push gem"
+task :release => "release:is_new_version" do
+  require 'tempfile'
+  
+  sh "gem build #{PRJ}.gemspec"
+
+  file = Tempfile.new "template"
+  begin
+    file.puts "release #{version}"
+    file.close
+    sh "git commit --allow-empty -a -v -t #{file.path}"
+  ensure
+    file.close unless file.closed?
+    file.unlink
+  end
+
+  sh "git tag #{tag}"
+  sh "git push"
+  sh "git push --tags"
+  
+  sh "gem push #{tag}.gem"
+end
+
+namespace :release do
+  desc "Diff to latest release"
+  task :diff do
+    latest = `git describe --abbrev=0 --tags --match '#{PRJ}-*'`.chomp
+    sh "git diff #{latest}"
+  end
+
+  desc "Log to latest release"
+  task :log do
+    latest = `git describe --abbrev=0 --tags --match '#{PRJ}-*'`.chomp
+    sh "git log #{latest}.."
+  end
+
+  task :is_new_version do
+    abort "#{tag} exists; update version!" unless `git tag -l #{tag}`.empty?
+  end
+end

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/bench/formula.rb

@@ -6,11 +6,10 @@
 # with
 #   CFLAGS   = -fPIC -O2 -march=i686 -msse2 -mfpmath=sse
 
+$CFLAGS="-fPIC -O2 -march=native"
 case RUBY_PLATFORM
 when /x86_64/
-  $CFLAGS="-fPIC -O2 -march=k8 -msse2 -mfpmath=sse"
-else
-  $CFLAGS="-fPIC -O2 -march=i686 -msse2 -mfpmath=sse"
+  $CFLAGS << " -msse2 -mfpmath=sse"
 end
 
 require 'redshift'

data/examples/pid.rb

@@ -9,14 +9,14 @@ srand(12345)
 # Variable with discrete and continuous perturbation.
 class Plant < Component
   continuous :x => 0, :t => 1
-  
+
   link :control => :Control # fwd ref to undefined class Control
-  
+
   flow do
     diff " x' = control.output + sin(t) "
     diff " t' = -1 "
   end
-  
+
   transition do
     guard "t <= 0"
     action do
@@ -30,14 +30,14 @@ end
 class Control < Component
   continuous :set_point => 2.0
   continuous :p_out, :i_out, :d_out, :output
-  
+
   # Gains
   constant :k_p => 1.0,
            :k_i => 1.0,
            :k_d => 1.0
-  
+
   link :plant => Plant
-  
+
   flow do
     algebraic     " error   = set_point - plant.x "
     algebraic     " p_out   = k_p * error "

data/examples/robots/lib/shell-world.rb

@@ -34,7 +34,7 @@ module ShellWorld
 
     loop do
       evolve 100000000 do
-        puts "clock: #{clock}"
+        printf "clock: %10.3f\n" % clock
         #sleep 0.01
       end
     end

data/examples/scheduler.rb

@@ -18,10 +18,14 @@ class Scheduler < RedShift::Component
   
   class Request
     include Comparable
+
     attr_accessor :time, :queue, :message
+
     def <=>(other)
       self.time <=> other.time
     end
+
+    # Scheduled request: at given +time+, send +message+ to +queue+.
     def initialize time, queue, message
       @time, @queue, @message = time, queue, message
     end
@@ -29,6 +33,7 @@ class Scheduler < RedShift::Component
   
   EPSILON = 1E-12 # float fuzziness, if timestep is 0.1, for example
   
+  # Schedule the sending of +message+ to +queue+, after +delta_t+ elapses.
   # Returns the request object for use with unschedule
   def schedule_message delta_t, queue, message
     req = Request.new(time + delta_t - EPSILON, queue, message)
@@ -82,7 +87,7 @@ class Client < RedShift::Component
   
   transition Enter => Waiting do
     action do
-      puts "scheduling message at #{world.clock} sec"
+      puts "scheduling message at #{world.clock} sec to run after #{delay} sec"
       scheduler.schedule_message delay, wakeup, "Time to wake up, snoozebrain!"
     end
   end

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

@@ -0,0 +1,184 @@
+#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;
+        unsigned int 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);
+}