redshift 1.3.17 → 1.3.18

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

@@ -0,0 +1,167 @@
+require 'redshift/mixins/shell'
+require 'redshift/util/plot'
+
+# Adds an interactive ruby shell with plotting and animation commands.
+module ShellWorld
+  include RedShift::Shell
+  
+  def entered
+    @entered ||= []
+  end
+  
+  def exited
+    @exited ||= []
+  end
+
+  def main_loop_with_shell_and_tk(argv=[])
+    if argv.delete "-h"
+      puts <<-END
+        
+        -s    start in shell
+              (otherwise, run until ^C breaks into shell)
+        
+        -t    start with tk animation
+              (otherwise, run without tk until the "tk" command)
+        
+      END
+      
+      exit
+    end
+    
+    puts "^C to break into shell; 'help' for shell help"
+    tk if argv.delete "-t"
+    shell.run if argv.delete "-s"
+
+    loop do
+      evolve 100000000 do
+        puts "clock: #{clock}"
+        #sleep 0.01
+      end
+    end
+  end
+
+  def help
+    puts <<-END
+      The current object is #{self.inspect}. Some commands:
+
+        q         -- quit
+        sh!       -- enter a system command shell
+        run N     -- run quickly for N time steps (integer)
+        evolve T  -- run quickly for T seconds (float)
+        tk        -- turn on Tk window (-t on command line to start this way)
+        tk false  -- turn off Tk window
+
+      Local vars persist between interrupts.
+      Continue slow execution by pressing Ctrl-D (maybe Ctrl-Z on windows).
+      Press Ctrl-C again to break into the shell. Use -s on command line
+      to start in shell.
+    END
+  end
+  
+  def sh!
+    system ENV['SHELL'] || default_shell
+  end
+  
+  def default_shell
+    puts "No SHELL environment variable, trying /bin/bash"
+    "/bin/bash"
+  end
+  
+  def next_id
+    @next_id ||= 1
+    @next_id += 1
+  end
+  
+  def create(*)
+    c = super
+    entered << c
+    c
+  end
+  
+  def before_shell
+    @tkar.catch_up_within 0 if @tkar
+    puts "\nStopped #{self.inspect}"
+  end
+  
+  def after_shell
+    @tkar.catch_up_within 0 if @tkar
+    puts "\nRunning #{self.inspect}"
+  end
+  
+  def dragger id, x, y
+    c = find {|c| c.id == id}
+    c.x, c.y = x, y
+  end
+  
+  def tk turn_on = true
+    require 'redshift/util/tkar-driver'
+    if turn_on
+      if not @tkar or @tkar.closed?
+        @tkar = TkarDriver.new(method :dragger) do |pipe|
+          pipe.puts <<-END
+            title Robot World
+            background gray95
+            height 600
+            width 600
+            view_at -50 -20
+            zoom_to 4
+
+            shape cone \ arc5,0,10,10,fc:yellow,oc:black,extent:30,start:165,style:pieslice \
+    text2,2,anchor:c,justify:center,width:100,text:*0,fc:blue
+
+            shape robot cone*0 \
+             arc5,5,2,2,fc:green,oc:green,extent:*1,start:0,style:pieslice \
+             arc5,-5,2,2,fc:red,oc:red,extent:*2,start:0,style:pieslice
+            
+            shape circle oval*0,*0,*1,*1,oc:red
+            shape explosion oval*0,*0,*1,*1,oc:*2,fc:*2
+            shape missile \
+arc2,0,4,4,fc:red,oc:black,extent:20,start:170,style:pieslice
+
+          END
+          ## the view_at seems to be needed to overcome a little
+          ## centering bug in tkar
+
+          each do |component|
+            pipe.puts component.tk_add if defined?(component.tk_add)
+          end
+        end
+
+        tk_update
+      end
+      
+    elsif not turn_on and @tkar
+      @tkar.close
+      @tkar = nil
+    end
+    @tkar
+  end
+  
+  def tk_update
+    if @tkar and
+       (entered.size > 0 or exited.size > 0 or (clock % 0.1).abs < 0.01)
+      @tkar.update do |pipe|
+        entered.each do |component|
+          pipe.puts component.tk_add if defined?(component.tk_add)
+        end
+
+        each do |component|
+          pipe.puts component.tk_update if defined?(component.tk_update)
+        end
+
+        exited.each do |component|
+          pipe.puts component.tk_delete if defined?(component.tk_delete)
+        end
+      end
+    end
+  end
+  
+  def run(*)
+    super do
+      tk_update
+      entered.clear
+      exited.clear
+      yield self if block_given?
+    end
+  end
+end

data/examples/robots/lib/tracker.rb

@@ -0,0 +1,16 @@
+# computes true distance and bearing angle to a single target,
+# but won't scale up very well
+class Tracker < RobotComponent
+  link :host => Robot
+  link :target => Robot
+  
+  flow do
+    alg " distance =
+        sqrt(
+          pow(host.x - target.x, 2) +
+          pow(host.y - target.y, 2) ) "
+    alg " angle =
+        atan2(target.y - host.y,
+              target.x - host.x) "
+  end
+end

data/examples/robots/robots.rb

@@ -0,0 +1,53 @@
+$LOAD_PATH.unshift 'lib'
+require 'base'
+
+world = RobotWorld.new
+world.time_step = 0.01
+
+r1 = world.create Robot do |r|
+  r.name = "robot 1"
+  r.x = 0
+  r.y = 0
+end
+
+r2 = world.create Robot do |r|
+  r.name = "robot 2"
+  r.x = -50
+  r.y = 0
+  r.heading = 0.1 * Math::PI
+  r.v = 10
+end
+
+r3 = world.create Robot do |r|
+  r.name = "robot 3"
+  r.x = 70
+  r.y = 10
+  r.heading = -0.9 * Math::PI
+  r.v = 5
+end
+
+30.times do |i|
+  world.create Missile do |m|
+    m.x = -40
+    m.y = 40 + i*2
+    m.v = 20 - (i%10)
+    m.target = r2
+  end
+end
+
+20.times do |i|
+  world.create Missile do |m|
+    m.x = -30
+    m.y = 40 + i*2
+    m.v = 20 - (i%10)
+    m.heading = i / 20
+    m.target = r3
+  end
+end
+
+robots = world.grep(Robot)
+robots.each do |r|
+  r.radar.track_robots robots - [r]
+end
+
+world.main_loop_with_shell_and_tk(ARGV)

data/examples/shell.rb

@@ -1,7 +1,6 @@
 # Shows how to use a customized IRB shell to handle Ctrl-C interrupts
 
 require 'redshift'
-require 'redshift/mixins/irb-shell'
 include RedShift
 
 require 'redshift/util/plot'
@@ -9,7 +8,7 @@ include Plot::PlotUtils
 
 # Adds an interactive ruby shell with plotting and animation commands.
 module ShellWorld
-  include RedShift::Shellable
+  include RedShift::World::Shell
 
   def help
     puts <<-END

data/ext/redshift/buffer/buffer.c

@@ -0,0 +1,102 @@
+#include "buffer.h"
+
+void rs_buffer_init(RSBuffer *buf, long len, double fill)
+{
+    int i;
+    buf->ptr = ALLOC_N(double, len);
+    buf->len = len;
+    buf->offset = 0;
+    for (i=0; i<len; i++) {
+      buf->ptr[i] = fill;
+    }
+}
+
+void rs_buffer_resize(RSBuffer *buf, long len)
+{
+    long    i;
+    long    old_len = buf->len;
+    long    offset  = buf->offset;
+    double *ptr     = buf->ptr;
+    double *dst, *src;
+    double  fill;
+    
+    if (len < old_len) {
+      if (offset < len) {
+        dst = ptr + offset;
+        src = ptr + offset + old_len - len;
+        memmove(dst, src, (len - offset) * sizeof(double));
+      }
+      else {
+        dst = ptr;
+        src = ptr + offset - len;
+        offset = 0;
+        memmove(dst, src, len * sizeof(double));
+      }
+      REALLOC_N(ptr, double, len);
+      // ## maybe better: don't release space, just use less of it
+    }
+    else if (len > old_len) {
+      REALLOC_N(ptr, double, len);
+    
+      fill = ptr[offset];
+      dst = ptr + offset + len - old_len;
+      src = ptr + offset;
+      memmove(dst, src, (old_len - offset) * sizeof(double));
+    
+      for (i = 0; i < len - old_len; i++) {
+        ptr[offset + i] = fill;
+      }
+    }
+    else
+      return;
+    
+    buf->len = len;
+    buf->offset = offset;
+    buf->ptr = ptr;
+}
+
+void rs_buffer_inhale_array(RSBuffer *buf, VALUE ary)
+{
+    int  size, i;
+    
+    Check_Type(ary, T_ARRAY);
+    
+    size = RARRAY_LEN(ary);
+    if (buf->ptr) {
+      REALLOC_N(buf->ptr, double, size);
+    }
+    else {
+      buf->ptr = ALLOC_N(double, size);
+    }
+    buf->len = size;
+    buf->offset = 0;
+    
+    for (i = 0; i < size; i++) {
+      buf->ptr[i] = NUM2DBL(RARRAY_PTR(ary)[i]);
+    }
+}
+
+VALUE rs_buffer_exhale_array(RSBuffer *buf)
+{
+    VALUE ary;
+    int i;
+    int j;
+    int size;
+    
+    size = buf->len;
+    ary = rb_ary_new2(size);
+    RARRAY_LEN(ary) = size;
+    for (i = buf->offset, j=0; i < size; i++, j++) {
+      RARRAY_PTR(ary)[j] = rb_float_new(buf->ptr[i]);
+    }
+    for (i = 0; i < buf->offset; i++, j++) {
+      RARRAY_PTR(ary)[j] = rb_float_new(buf->ptr[i]);
+    }
+    
+    return ary;
+}
+
+void
+Init_buffer()
+{
+}

data/ext/redshift/buffer/buffer.h

@@ -0,0 +1,17 @@
+#ifndef buffer_h
+#define buffer_h
+
+#include <ruby.h>
+
+typedef struct {
+  long    len;
+  long    offset;
+  double  *ptr;
+} RSBuffer;
+
+void rs_buffer_init(RSBuffer *buf, long len, double fill);
+void rs_buffer_resize(RSBuffer *buf, long len);
+void rs_buffer_inhale_array(RSBuffer *buf, VALUE ary);
+VALUE rs_buffer_exhale_array(RSBuffer *buf);
+
+#endif

data/ext/redshift/buffer/dir.rb

@@ -0,0 +1 @@
+REDSHIFT_BUFFER_DIR = File.dirname(File.expand_path(__FILE__))

data/ext/redshift/buffer/extconf.rb

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

data/ext/redshift/util/isaac/extconf.rb

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

data/ext/redshift/util/isaac/isaac.c

@@ -0,0 +1,129 @@
+#include "ruby.h"
+#include "rand.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);
+}
+
+/*
+ * 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]);
+    }
+    rs_isaac_init(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--) {
+        rs_isaac_rand(ctx);
+        ctx->randcnt=RANDSIZ-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--) {
+        rs_isaac_rand(ctx);
+        ctx->randcnt=RANDSIZ-1;
+    }
+    
+    return rb_float_new(ctx->randrsl[ctx->randcnt] / 4294967295.0);
+}
+
+/* :nodoc: */
+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;
+}
+
+/* :nodoc: */
+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;
+}
+
+void
+Init_isaac()
+{
+    VALUE ISAAC;
+
+    ISAAC = rb_define_class("ISAAC", rb_cObject);
+    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_const_set(ISAAC, rb_intern("RANDSIZ"), UINT2NUM(RANDSIZ));
+}