narray 0.5.9.4

data/src/nimage/demo/life_na.rb

@@ -0,0 +1,57 @@
+# NArray demo : life game
+# by Masahiro Tanaka <masa@ir.isas.ac.jp>  2001-01-18
+
+require 'narray'
+require 'nimage'
+
+class NArray
+  def magnify(n)
+    src = shape.collect{|x| [1,x]}.flatten
+    dst = shape.collect{|x| [n,x]}.flatten
+    a = NArray.new(typecode,*dst)
+    a[*[true]*(rank*2)] = self.reshape(*src)
+    a.reshape!(*NArray[*shape]*n)
+  end
+end
+
+class LifeGame
+  def initialize(nx,ny)
+    @d = NArray.byte(nx,ny)
+    w = 50
+    @d[nx/2-w,ny/2-w] = NArray.byte(w*2+1,w*2+1).random!(2)
+    @step = 0
+    @win = NImage.show @d #.magnify(2)
+  end
+
+  def life_step
+    sum = 
+      @d[0..-3,0..-3] + @d[0..-3,1..-2] + @d[0..-3,2..-1] +
+      @d[1..-2,0..-3]                   + @d[1..-2,2..-1] +
+      @d[2..-1,0..-3] + @d[2..-1,1..-2] + @d[2..-1,2..-1]
+    @d[1,1] =
+      (sum.eq 3) | ((sum.eq 2) & @d[1..-2,1..-2])
+    @step += 1
+    @win.update( (@d*(NImage.ncolors-1)).to_s )
+  end
+
+  def close
+    @win.close
+  end
+
+  attr_reader :step
+end
+
+srand(1)
+a = LifeGame.new(200,200)
+
+print "Hit return key to start..."
+STDIN.getc
+
+begin
+  loop{ a.life_step }
+ensure
+  printf "step=%i\n",a.step
+  print "Hit return key..."
+  STDIN.getc
+  a.close
+end

data/src/nimage/demo/mandel.rb

@@ -0,0 +1,41 @@
+# NArray demo : Mandelbrot
+
+require 'narray'
+
+def mandel(w,h)
+  zoom=3.5
+
+  z = ( NArray.scomplex(w,1).indgen!/w-0.65 )*zoom + 
+      ( NArray.scomplex(1,h).indgen!/h-0.5 )*(zoom*1.im)
+  c = z.dup
+  a = NArray.sint(h,w)
+  idx = NArray.int(h,w).indgen!
+
+  for i in 1..30
+    z = z**2+c
+    idx_t,idx_f = (z.abs>2).where2
+    print i," size=",idx_t.size,"\n"
+    ii = idx[idx_t]
+    a[ii] = i
+    break if idx_f.size==0
+    idx = idx[idx_f]
+    z = z[idx_f]
+    c = c[idx_f]
+  end
+  a
+end
+
+
+#
+#    TEST TEST TEST
+#
+if __FILE__ == $0
+
+  require 'nimage'
+
+  win = NImage.show mandel(400,400)
+
+  print "Hit return key..."
+  STDIN.getc
+  win.close
+end

data/src/nimage/extconf.rb

@@ -0,0 +1,12 @@
+require 'mkmf'
+
+# configure options:
+#  --with-x11-dir=path
+#  --with-x11-include=path
+#  --with-x11-lib=path
+dir_config("x11")
+
+#have_header("X11/Xlib.h")
+#have_header("X11/Xutil.h")
+have_library("X11", "XOpenDisplay")
+create_makefile("nimage_c")

data/src/nimage/lib/nimage.rb

@@ -0,0 +1,51 @@
+require "narray"
+require "nimage_c"
+
+def NImage.show image
+
+  r1 = image.min
+  r2 = image.max
+  b  = NArray.byte(*image.shape)
+  b[]= (image.to_f-r1)/(r2-r1)*(NImage.ncolors-1)
+
+  NImage.new b.to_s, *b.shape
+end
+
+def NImage.standard_color
+  ncol = 32/4
+  t = NArray.byte(ncol).indgen! * (255.0/ncol)
+  r = NArray.byte(ncol,4)
+  g = NArray.byte(ncol,4)
+  b = NArray.byte(ncol,4)
+
+  # Color map
+  r[0..-1,1] = 
+    g[0..-1,2] = 
+    b[0..-1,0] = 
+    b[-1..0,1] = 
+    b[0..-1,3] = t
+  r[0..-1,2] = 
+    r[0..-1,3] = 
+    g[0..-1,3] = 255
+
+  NImage.colormap r.to_s, g.to_s, b.to_s
+end
+
+# Initalize colormap
+#NImage.standard_color
+
+#
+#    TEST TEST TEST
+#
+if __FILE__ == $0
+
+  x = NArray.sfloat(200,1).indgen!(-100)/50*3.1415
+  y = NArray.sfloat(1,200).indgen!(-100)/50*3.1415
+  z = NMath.cos(x) * NMath.sin(y)
+
+  v = NImage.show z
+
+  print "Hit return key..."
+  STDIN.getc
+  v.close
+end

data/src/nimage/nimage.c

@@ -0,0 +1,328 @@
+/*
+   NImage 
+   --- A Ruby Extension Library for displaying Images on X11
+       (C) Copyright 2000 by Masahiro TANAKA
+*/
+
+#include <stdio.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include "ruby.h"
+
+static VALUE cNImage;
+
+struct NIMG {
+  char  *image;
+  int    width;
+  int    height;
+  Window window;
+};
+
+#define MAX_COLOR 256
+
+static Display *display;
+static GC       gc=NULL;
+static XColor   color[MAX_COLOR];
+
+static int ncolor = 32;
+static int color_allocated = 0;
+
+static void color_alloc_gray()
+{
+  int i;
+  Colormap cmap;
+
+  cmap = DefaultColormap(display, 0);
+  for (i=0; i<ncolor; i++) {
+    color[i].red   = 
+    color[i].green = 
+    color[i].blue  = (i*65535)/ncolor;
+    if ( !XAllocColor( display, cmap, &color[i] ) )
+      rb_raise(rb_eRuntimeError, "ERROR: cannot allocate Color\n" );
+  }
+  color_allocated = 1;
+}
+
+
+static void color_alloc(int n, char *r, char *g, char *b)
+{
+  int i;
+  Colormap cmap;
+
+  cmap = DefaultColormap(display, 0);
+  for (i=0; i<n; i++) {
+    color[i].red   = r[i]*256;
+    color[i].green = g[i]*256;
+    color[i].blue  = b[i]*256;
+    if ( !XAllocColor( display, cmap, &color[i] ) )
+      rb_raise(rb_eRuntimeError, "ERROR: cannot allocate Color\n" );
+  }
+  ncolor = n;
+  color_allocated = 1;
+}
+
+
+static void color_free()
+{
+  int i;
+  Colormap cmap;
+
+  if (color_allocated) {
+    cmap = DefaultColormap(display, 0);
+    for (i=0; i<ncolor; i++)
+      XFreeColors(display, cmap, &color[i].pixel, 1, 0);
+    color_allocated = 0;
+  }
+}
+
+static VALUE nimg_colormap(VALUE self, VALUE val_r, VALUE val_g, VALUE val_b)
+{
+  char *r, *g, *b;
+  int nr, ng, nb, n;
+
+  r  = RSTRING(val_r)->ptr;
+  nr = RSTRING(val_r)->len;
+  g  = RSTRING(val_g)->ptr;
+  ng = RSTRING(val_g)->len;
+  b  = RSTRING(val_b)->ptr;
+  nb = RSTRING(val_b)->len;
+
+  n = (nr<ng) ? nr:ng;
+  n = (n <nb) ? n :nb;
+  if (n > MAX_COLOR)
+    rb_raise(rb_eArgError, "exceed maximum # of colors");
+
+  color_free();
+  color_alloc(n,r,g,b);
+  XFlush(display);
+
+  return Qnil;
+}
+
+static VALUE nimg_ncolors(VALUE self)
+{
+  return INT2NUM(ncolor);
+}
+
+static XImage *create_ximage(struct NIMG *nimg)
+{
+  XImage *image;
+  Visual *visual;
+  int malloc_len;
+  int depth;
+
+  depth = DefaultDepth(display, DefaultScreen(display));
+  visual = CopyFromParent;
+
+  image = XCreateImage( display, visual, depth,
+			ZPixmap, 0, 0, nimg->width, nimg->height,
+			32, 0 );
+
+  malloc_len = image->bytes_per_line * image->height;
+  image->data = (unsigned char*) malloc(malloc_len);
+  memset(image->data, 0, malloc_len);
+
+  return image;
+}
+
+
+static void nimg_put_image(struct NIMG *nimg)
+{
+  XImage *ximage;
+  int i, j, k;
+
+  if (!color_allocated)
+    color_alloc_gray();
+
+  ximage = create_ximage(nimg);
+
+  k=0;
+  for (j=nimg->height-1; j>=0; j--)
+    for (i=0; i<nimg->width; i++)
+      XPutPixel(ximage, i,j, color[nimg->image[k++]].pixel);
+
+  XPutImage( display, nimg->window, gc,
+	     ximage, 0, 0,
+	     0,0, nimg->width, nimg->height );
+
+  XFlush(display);
+  XDestroyImage(ximage);
+}
+
+
+static void init_display(void)
+{
+  display = XOpenDisplay( NULL );
+  if ( display==NULL )
+    rb_raise(rb_eRuntimeError, "ERROR: cannot open display\n");
+}
+
+
+static void init_wm(struct NIMG *nimg)
+{
+  XTextProperty  text;
+  XSizeHints     size;
+
+  /* for window managers */
+  text.value    = (unsigned char*)"NImage";
+  text.encoding = 31;
+  text.format   = 8;
+  text.nitems   = strlen( (char*)text.value );
+
+  size.flags = PPosition | PMinSize | PMaxSize;
+  /*size.flags  = PPosition | PSize;*/
+  size.width =
+  size.min_width =
+  size.max_width = nimg->width;
+  size.height =
+  size.min_height = 
+  size.max_height = nimg->height;
+  size.x = 0;
+  size.y = 0;
+
+  XSetWMProperties( display, nimg->window,
+		    &text, &text, NULL, 0, &size, NULL, NULL );
+}
+
+
+static void show_window(Window window)
+{
+  XEvent event;
+  /* show window */
+  XMapWindow( display, window );
+  do XNextEvent( display, &event );
+  while ( event.type != Expose );
+}
+
+
+static void nimg_init_window(struct NIMG *nimg)
+{
+  int screen, depth;
+  Window parent, window;
+  Visual *visual;
+  XSetWindowAttributes attr;
+  unsigned long bgcolor;
+  unsigned long mask = CWBackingStore | CWEventMask;
+  unsigned long event_mask =
+    ExposureMask
+    | ButtonPressMask
+    | ButtonReleaseMask
+    | EnterWindowMask
+    | LeaveWindowMask
+    | KeyPressMask
+    | KeyReleaseMask
+    | PointerMotionMask
+    | StructureNotifyMask ;
+
+  screen = DefaultScreen( display );
+  parent = RootWindow( display, screen );
+  depth  = DefaultDepth( display, screen );
+  visual = DefaultVisual( display, screen );
+  bgcolor = BlackPixel( display, screen );
+  
+  attr.backing_store = /*Always*/ WhenMapped;
+  attr.event_mask = event_mask;
+
+  nimg->window = 
+    XCreateWindow( display, parent,
+		   0, 0, nimg->width, nimg->height,
+		   1, depth, InputOutput, visual,
+		   mask, &attr);
+  if (gc==NULL)
+    gc = XCreateGC( display, nimg->window, 0, 0 );
+
+  XSetWindowBackground( display, nimg->window, bgcolor );
+
+  init_wm( nimg );
+  show_window( nimg->window );
+}
+
+
+/* free contents */
+static void
+ nimg_free(struct NIMG* nimg)
+{
+  free( nimg->image );
+  free( nimg );
+}
+
+
+static VALUE
+ nimg_new( VALUE self, VALUE val_image, VALUE val_wid, VALUE val_hei )
+{
+  struct NIMG *nimg;
+  char *data;
+  int   i, len;
+
+  data = RSTRING(val_image)->ptr;
+  len  = RSTRING(val_image)->len;
+
+  nimg = ALLOC( struct NIMG );
+  nimg->image = ALLOC_N( char, len );
+  MEMCPY( nimg->image, data, char, len );
+
+  nimg->width  = NUM2INT(val_wid);
+  nimg->height = NUM2INT(val_hei);
+ 
+  if (len != nimg->width * nimg->height)
+    rb_raise(rb_eArgError, "Image size mismatch");
+
+  nimg_init_window(nimg);
+  nimg_put_image(nimg);
+
+  return Data_Wrap_Struct(cNImage, NULL, nimg_free, nimg);
+}
+
+
+static VALUE
+ nimg_update( VALUE self, VALUE val_image )
+{
+  struct NIMG *nimg;
+  char *data;
+  int   i, len;
+
+  Data_Get_Struct( self, struct NIMG, nimg );
+  data = RSTRING(val_image)->ptr;
+  len  = RSTRING(val_image)->len;
+
+  if (len != nimg->width * nimg->height)
+    rb_raise(rb_eArgError, "Image size mismatch");
+
+  MEMCPY( nimg->image, data, char, len );
+
+  nimg_put_image(nimg);
+  return Qnil;
+}
+
+
+static VALUE
+ nimg_close( VALUE self )
+{
+  struct NIMG *nimg;
+
+  Data_Get_Struct( self, struct NIMG, nimg );
+  XDestroyWindow( display, nimg->window );
+  nimg->window = 0;
+  XFlush( display );
+  return self;
+}
+
+
+void
+  Init_nimage_c()
+{
+  /* open display, etc. */
+  init_display();
+
+  /* define NImage class */
+  cNImage = rb_define_class( "NImage", rb_cObject );
+
+  /* class methods */
+  rb_define_singleton_method( cNImage, "new", nimg_new, 3 );
+  rb_define_singleton_method( cNImage, "colormap", nimg_colormap, 3 );
+  rb_define_singleton_method( cNImage, "ncolors", nimg_ncolors, 0 );
+
+  /* method */
+  rb_define_method( cNImage, "update", nimg_update, 1 );
+  rb_define_method( cNImage, "close", nimg_close, 0 );
+}

data/src/speed/add.py

@@ -0,0 +1,12 @@
+from mybench import *
+
+a = bench_array()
+b = bench_array()
+
+print "a.typecode:",a.typecode(),",  a.shape:",a.shape
+print "b.typecode:",b.typecode(),",  b.shape:",b.shape
+print "calculating c = a+b ..."
+
+def bench_body(a=a,b=b): c=a+b
+
+bench_time(bench_body)

data/src/speed/add.rb

@@ -0,0 +1,8 @@
+require 'mybench'
+
+a, b = bench_float
+
+print "a = "; p a;
+print "calculating c = a+b ...\n"
+
+bench_time{ c = a+b }

data/src/speed/add_int.py

@@ -0,0 +1,12 @@
+from mybench import *
+
+a = arrayrange(ARRSZ)
+b = arrayrange(ARRSZ)
+
+print "a.typecode:",a.typecode(),",  a.shape:",a.shape
+print "b.typecode:",b.typecode(),",  b.shape:",b.shape
+print "calculating c = a+b ..."
+
+def bench_body(a=a,b=b): c=a+b
+
+bench_time(bench_body)

data/src/speed/add_int.rb

@@ -0,0 +1,9 @@
+require 'mybench'
+
+a, b = bench_int
+
+print "a = "; p a;
+print "b = "; p b;
+
+print "calculating c = a+b ...\n"
+bench_time{ c=a+b }

data/src/speed/lu.m

@@ -0,0 +1,14 @@
+# mesuring performance of Octave
+
+n = 1000;
+m = linspace(0,n*n-1,n*n);
+m = rem(m, n+1) + 1;
+m = reshape(m,n,n);
+
+printf ("executing %ix%i LU...\n",n,n);
+[t1, u1, s1] = cputime ();
+[l,u,p] = lu(m);
+[t2, u2, s2] = cputime ();
+printf (" Time: %5.2f sec\n", u2 - u1);
+# Time: 20.43 sec, GNU Octave, version 2.0.16 (sparc-sun-solaris2.7).
+exit

data/src/speed/lu.rb

@@ -0,0 +1,22 @@
+require 'mybench'
+
+n = 1000
+m = NArray.float(n,n).indgen!
+m = m % (n+1) + 1
+m = NMatrix.ref(m).transpose
+
+puts 'm ='
+p m
+
+printf "executing %ix%i LU...\n",n,n
+bench_time(1){lu = m.lu}
+exit
+
+puts 'lu='
+p lu
+puts 'y='
+p y
+puts 'm*y='
+p m*y
+
+#system "ps -v"

data/src/speed/mat.m

@@ -0,0 +1,23 @@
+# mesuring performance of Octave
+
+n = 500;
+
+a = linspace(0,n*n-1,n*n);
+a = rem(a, n+1) + 1;
+a = reshape(a,n,n);
+
+b = linspace(0,n*n-1,n*n);
+b = rem(b, n-1) + 1;
+b = reshape(b,n,n);
+
+printf ("executing product of %ix%i Matrix...\n",n,n);
+printf ("c=a*b\n");
+
+[t1, u1, s1] = cputime ();
+c = a*b;
+[t2, u2, s2] = cputime ();
+
+printf (" Time: %f\n", u2 - u1);
+# Time: 7.280000
+# GNU Octave, version 2.0.16 (sparc-sun-solaris2.7).
+exit

data/src/speed/mat.rb

@@ -0,0 +1,28 @@
+require 'mybench'
+
+n = 500
+
+a = NArray.float(n,n).indgen!
+a = a % (n+1) + 1
+a = NMatrix.ref(a)#.transpose
+
+b = NArray.float(n,n).indgen!
+b = b % (n-1) + 1
+b = NMatrix.ref(b)#.transpose
+
+c = 0
+
+puts 'a='
+p a
+puts 'b='
+p b
+
+printf "executing %ix%i Matrix product...\n",n,n
+puts 'c=a*b'
+
+bench_time(1) { c=a*b }
+
+# time: 4.21 sec
+
+puts 'c='
+p c

data/src/speed/mul.py

@@ -0,0 +1,12 @@
+from mybench import *
+
+a = bench_array()
+b = bench_array()
+
+print "a.typecode:",a.typecode(),",  a.shape:",a.shape
+print "b.typecode:",b.typecode(),",  b.shape:",b.shape
+print "calculating c = a*b ..."
+
+def bench_body(a=a,b=b): c=a*b
+
+bench_time(bench_body)

data/src/speed/mul.rb

@@ -0,0 +1,9 @@
+require 'mybench'
+
+a, b = bench_float
+
+print "a = "; p a;
+print "b = "; p b;
+print "calculating c = a*b ...\n"
+
+bench_time{ c = a*b }

data/src/speed/mul2.py

@@ -0,0 +1,15 @@
+from mybench import *
+
+a = reshape(arrayrange(1000),(1000,1)).astype(Float64)
+b = reshape(arrayrange(1000),(1,1000)).astype(Float64)
+
+print "a.typecode:",a.typecode(),",  a.shape:",a.shape
+print "b.typecode:",b.typecode(),",  b.shape:",b.shape
+print "calculating  c = a*b ..."
+
+def bench_body(a=a,b=b): c=a*b
+
+bench_time(bench_body)
+
+c = a*b
+print "c.shape:", c.shape,"\n"

data/src/speed/mul2.rb

@@ -0,0 +1,13 @@
+require 'mybench'
+
+a = NArray.float(1000,1).indgen!
+b = NArray.float(1,1000).indgen!
+c = 0
+
+print "a = "; p a;
+print "b = "; p b;
+print "calculating c = a*b ...\n"
+
+bench_time{ c = a*b }
+
+print "c = "; p c;

data/src/speed/mul_comp.py

@@ -0,0 +1,12 @@
+from mybench import *
+
+a = bench_array(Complex64)
+b = bench_array(Complex64)
+
+print "a.typecode:",a.typecode(),",  a.shape:",a.shape
+print "b.typecode:",b.typecode(),",  b.shape:",b.shape
+print "calculating c = a*b ..."
+
+def bench_body(a=a,b=b): c=a*b
+
+bench_time(bench_body)

data/src/speed/mul_comp.rb

@@ -0,0 +1,9 @@
+require 'mybench'
+
+a, b = bench_complex
+
+print "a = "; p a;
+print "b = "; p b;
+print "calculating c = a*b ...\n"
+
+bench_time{ c = a*b }