narray 0.5.9.4 → 0.5.9.5

data/src/ChangeLog

@@ -1,3 +1,32 @@
+2008-06-10  Masahiro TANAKA  <masa16.tanaka at gmail.com>
+
+	* bench/: new sophisticated benchmark script.
+
+	* ver 0.5.9p5
+
+2008-05-27  Jose M <braket at hotmai...>
+
+	* na_array.c, na_index.c, na_random.c, na_func.c:
+	* na_linalg.c, narray.c, mkmath.rb, mkop.rb:
+	  change var++ to ++var: make NArray perform faster.
+
+2008-05-24  Hiroki Motoyoshi <himotoyoshi at yahoo.co...>
+
+	* mkmath.rb:
+	  fix bug in powOO.
+
+2008-04-02  David MacMahon <davidm at astro.berkeley...>
+
+	* na_func.c:
+	  new methods: conj!, conjugate!
+
+2008-01-11  David MacMahon <davidm at astro.berkeley...>
+
+	* lib/narray_ext.rb (stddev):
+	  fix for complex NArrays.
+	* lib/narray_ext.rb (rms, rmsdev):
+	  new methods.
+
 2008-01-28  Masahiro TANAKA  <masa16.tanaka at gmail.com>
 
 	* na_array.c (na_range_to_sequence, na_do_mdai): 

data/src/MANIFEST

@@ -20,42 +20,6 @@ narray.h
 narray_local.h
 lib/narray_ext.rb
 lib/nmatrix.rb
-nimage/README.en
-nimage/extconf.rb
-nimage/nimage.c
-nimage/demo
-nimage/demo/fits.rb
-nimage/demo/fits_convol.rb
-nimage/demo/fits_fftdemo.rb
-nimage/demo/fitsdemo1.rb
-nimage/demo/fitsdemo2.rb
-nimage/demo/fitsdemo3.rb
-nimage/demo/fitsmorph.rb
-nimage/demo/life_na.rb
-nimage/demo/mandel.rb
-nimage/lib
-nimage/lib/nimage.rb
-speed/add.py
-speed/add.rb
-speed/add_int.py
-speed/add_int.rb
-speed/lu.m
-speed/lu.rb
-speed/mat.m
-speed/mat.rb
-speed/mul.py
-speed/mul.rb
-speed/mul2.py
-speed/mul2.rb
-speed/mul_comp.py
-speed/mul_comp.rb
-speed/mul_int.py
-speed/mul_int.rb
-speed/mybench.py
-speed/mybench.rb
-speed/solve.m
-speed/solve.py
-speed/solve.rb
 test/statistics.rb
 test/testarray.rb
 test/testbit.rb
@@ -80,3 +44,10 @@ test/testsort.rb
 test/teststr.rb
 test/testtrans.rb
 test/testwhere.rb
+bench/all.rb
+bench/bench.m
+bench/bench.py
+bench/bench.rb
+bench/dummy.m
+bench/dummy.py
+bench/dummy.rb

data/src/README.en

@@ -9,7 +9,6 @@
     using assignment with number, range, array index.
   + Operator: +,-,*,/,%,**, etc.
   + FFTW version 2 or 3 is separately supported.
-      http://www.ir.isas.ac.jp/~masa/ruby/dist/ruby-fftw3-0.1.0.tar.gz
   + NImage: Image viewer class.
   + Ruby/PGPLOT: Graphics library interface (separately distributed)
      X-Y Graph, Histogram, Contour map, Image map, etc.
@@ -27,9 +26,6 @@
 
 * Installation
 
-  + If you want to use FFTW, install it.
-    http://www.fftw.org/ or http://www.netlib.org/
-
   + Compile & Install NArray
 
     ruby extconf.rb
@@ -51,4 +47,4 @@
 
 * Author
 
-    Masahiro TANAKA <masa@ir.isas.ac.jp>
+    Masahiro TANAKA <masa16.tanaka@gmail.com>

data/src/README.ja

@@ -12,7 +12,6 @@
     $B$?$@$7!"%5%$%:$,(B1$B$N<!85$O!"B>J}$NG[Ns$N%5%$%:$K9g$o$;$F(B
     $B!V7+$jJV$7!WF1$8MWAG$,E,MQ$5$l$k!#(B
   + FFTW ($B9bB.%U!<%j%(JQ49(B) version 3 $B$O<!$N%b%8%e!<%k$G%5%]!<%H!#(B
-      http://www.ir.isas.ac.jp/~masa/ruby/dist/ruby-fftw3-0.1.0.tar.gz
   + NImage (X11$B%$%a!<%8I=<((B) $B%/%i%9ImB0!#(B(nimage/ $B%G%#%l%/%H%j;2>H(B)
   + Ruby/PGPLOT ($B%0%i%U%#%C%/%9%i%$%V%i%j!"JLW}(B) $B$K$F(B
      XY$B%0%i%U!"%R%9%H%0%i%`!"Ey9b@~!"%$%a!<%8I=<(2DG=!#(B
@@ -51,7 +50,7 @@
 * $BCx<T(B
 
   $BEDCf>;9((B
-  $B$40U8+!$%P%0%l%]!<%H$=$NB>$O(B masa@ir.isas.ac.jp $B$^$G$*4j$$$7$^$9!#(B
+  $B$40U8+!$%P%0%l%]!<%H$=$NB>$O(B masa16.tanaka@gmail.com $B$^$G$*4j$$$7$^$9!#(B
 
 * $B<U<-(B
 

data/src/SPEC.en

@@ -1,5 +1,5 @@
 
-	Ruby/NArray  ver 0.5.9 (2006-08-09)	by Masahiro TANAKA
+	Ruby/NArray  ver 0.5.9p5 (2008-05-28)	by Masahiro TANAKA
 
 
 Class method:
@@ -157,16 +157,22 @@ Comparison
 	e.g.: idx_t,idx_f = (a>12).where2
 
 Statistics
-    self.sum(dim,..)     Summation of elements in specified dimensions.
-    self.mean(dim,..)    Mean of elements in specified dimensions.
-    self.stddev(dim,..)  Standard deviation of elements in the dimensions.
-    self.min(dim,..)     Minimum in the specified dimensions.
-    self.max(dim,..)     Maximum in the specified dimensions.
-	  (All dimensions if omitted, Range can be used)
+    self.sum(dim,..)     Summation
+    self.mean(dim,..)    Mean
+    self.stddev(dim,..)  Standard deviation
+    self.rms(dim,..)     Root mean square
+    self.rmsdev(dim,..)  Root mean square deviation
+    self.min(dim,..)     Minimum
+    self.max(dim,..)     Maximum
+	note: * If dimensions are specified, statistics are performed
+	      	on those dimensions and the rest dimensions are kept.
+	      * Range can be used.
+	      * If dimension is not specified, statistics are performed
+	        for all the elements.
     self.median(dim)	 Median in 0..dim (All dimensions if omitted)
 
 Sort
-    self.sort(dim)	  Sort in the 0..dim (All dimensions if omitted)
+    self.sort(dim)	  Sort in 0..dim (All dimensions if omitted)
     self.sort_index(dim)  Return index of Sort result.
 			     self[self.sort_index] equals to self.sort.
 
@@ -222,6 +228,7 @@ Complex compound number
     self.real
     self.imag
     self.conj
+    self.conj!
     self.angle		atan2(self.imag, self.real)
     self.imag= other	set imaginary part
     self.im		multiply by imaginary unit

data/src/SPEC.ja

@@ -1,5 +1,5 @@
 
-	Ruby/NArray  ver 0.5.9 (2006-08-09)	by Masahiro TANAKA
+	Ruby/NArray  ver 0.5.9p5 (2008-05-28)	by Masahiro TANAKA
 
 
 $B%/%i%9%a%=%C%I(B:
@@ -149,7 +149,9 @@
 $BE}7W(B
     self.sum(dim,..)	    $B;XDj$7$?<!85$NOB!#(B
     self.mean(dim,..)       $B;XDj$7$?<!85$NJ?6Q!#(B
-    self.stddev(dim,..)     $B;XDj$7$?<!85$NI8=`JP:9!#(B
+    self.stddev(dim,..)     $B;XDj$7$?<!85$NI8=`JP:9(B($BI8K\I8=`JP:9(B)$B!#(B
+    self.rms(dim,..)        $B;XDj$7$?<!85$N(Broot mean square$B!#(B
+    self.rmsdev(dim,..)     $B;XDj$7$?<!85$N(Broot mean square deviation$B!#(B
     self.min(dim,..)        $B;XDj$7$?<!85$N:G>.!#(B
     self.max(dim,..)        $B;XDj$7$?<!85$N:GBg!#(B
 			    ($B>JN,;~$OA4$F$N<!85!#(BRange$B;XDj2D!#(B)
@@ -208,6 +210,7 @@ Boolean / $B%^%9%/4X78(B
     self.real
     self.imag
     self.conj
+    self.conj!
     self.angle		atan2(self.imag, self.real)
     self.imag= other	$B5u?tItJ,$K(Bother$B$r%;%C%H!#(B
     self.im		$B5u?tG\!#(B

data/src/bench/all.rb

@@ -0,0 +1,88 @@
+require "narray"
+T = (RUBY_VERSION<"1.8.0") ? Time : Process
+
+ruby_narray = system( "ruby -r narray dummy.rb" )
+python_numeric = system( "python dummy.py numeric" )
+python_numarray = system( "python dummy.py numarray" )
+python_numpy = system( "python dummy.py numpy" )
+octave = system( "octave -qf dummy.m" )
+
+def array_size
+  list = [
+    100000, 200000, 500000,
+    1000000, 2000000, 5000000,
+    10000000, 20000000, 50000000
+  ]
+  mlist = [
+    150, 200, 300, 500, 700, 1000, 1500, 2000, 3000
+    #300, 400, 700, 1000, 1400, 2000, 3000, 4000, 7000
+  ]
+
+  r = 50
+  n = nil
+  i = nil
+  list.each_with_index do |n,i|
+    a = NArray.float(n)
+    b = NArray.float(n)
+    t = bench_time(r) { c = a+b }
+    break if t>0.5
+  end
+  [n, mlist[i], r*2]
+end
+
+def bench_time(n)
+  t1 = T.times.utime
+   for i in 1..n
+     yield
+   end
+  t = T.times.utime - t1
+  puts " Time: %.2f sec\n" % [t]
+  t
+end
+
+n,m,r = array_size
+puts "array size = #{n}, repeat = #{r}\n\n"
+
+system "ruby   bench.rb          float  mul #{n} #{r}" if ruby_narray
+system "python bench.py numeric  float  mul #{n} #{r}" if python_numeric
+system "python bench.py numarray float  mul #{n} #{r}" if python_numarray
+system "python bench.py numpy    float  mul #{n} #{r}" if python_numpy
+system "octave -qf bench.m       float  mul #{n} #{r}" if octave         
+puts
+
+system "ruby   bench.rb          int  add #{n} #{r}" if ruby_narray	 
+system "python bench.py numeric  int  add #{n} #{r}" if python_numeric 
+system "python bench.py numarray int  add #{n} #{r}" if python_numarray
+system "python bench.py numpy    int  add #{n} #{r}" if python_numpy	 
+system "octave -qf bench.m       int  add #{n} #{r}" if octave         
+puts
+
+system "ruby   bench.rb          complex  mul #{n} #{r}" if ruby_narray	 
+system "python bench.py numeric  complex  mul #{n} #{r}" if python_numeric 
+system "python bench.py numarray complex  mul #{n} #{r}" if python_numarray
+system "python bench.py numpy    complex  mul #{n} #{r}" if python_numpy	 
+system "octave -qf bench.m       complex  mul #{n} #{r}" if octave         
+puts
+
+system "ruby   bench.rb          float_cross mul    #{m*2} #{r}" if ruby_narray	 
+system "python bench.py numeric  float_cross mul    #{m*2} #{r}" if python_numeric 
+system "python bench.py numarray float_cross mul    #{m*2} #{r}" if python_numarray
+system "python bench.py numpy    float_cross mul    #{m*2} #{r}" if python_numpy	 
+system "octave -qf bench.m       float_cross matmul #{m*2} #{r}" if octave         
+puts
+
+system "ruby   bench.rb          float_matrix mul    #{m} 4" if ruby_narray	 
+system "python bench.py numeric  float_matrix matmul #{m} 4" if python_numeric 
+system "python bench.py numarray float_matrix matmul #{m} 4" if python_numarray
+system "python bench.py numpy    float_matrix matmul #{m} 4" if python_numpy	 
+system "octave -qf bench.m       float_matrix matmul #{m} 4" if octave         
+puts
+
+system "ruby   bench.rb          float_solve solve #{m} 2" if ruby_narray	 
+system "python bench.py numeric  float_solve solve #{m} 2" if python_numeric 
+system "python bench.py numarray float_solve solve #{m} 2" if python_numarray
+system "python bench.py numpy    float_solve solve #{m} 2" if python_numpy	 
+system "octave -qf bench.m       float_solve solve #{m} 2" if octave         
+puts
+
+exit

data/src/bench/bench.m

@@ -0,0 +1,61 @@
+#! /bin/octave -qf
+
+arg_list = argv();
+TYPE   = arg_list{1};
+OP     = arg_list{2};
+ARRSZ  = str2num(arg_list{3});
+REPEAT = str2num(arg_list{4});
+n = ARRSZ;
+
+switch(TYPE)
+  case "float"
+    a = linspace(0,n-1,n);
+    b = linspace(0,n-1,n);
+  case "int"
+    a = int32(linspace(0,n-1,n));
+    b = int32(linspace(0,n-1,n));
+  case "complex"
+    a = complex(linspace(0,n-1,n));
+    b = complex(linspace(0,n-1,n));
+  case "float_cross"
+    a = linspace(0,n-1,n)';
+    b = linspace(0,n-1,n);
+  case "float_matrix"
+    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);
+  case "float_solve"
+    a = linspace(0,n*n-1,n*n);
+    a = rem(a, n+1) + 1;
+    a = reshape(a,n,n);
+    b = reshape(linspace(1,n*n,n*n),n,n);
+endswitch
+
+[t1, u1, s1] = cputime ();
+switch(OP)
+  case "add"
+    for i = 1:REPEAT
+      c = a + b;
+    endfor
+  case "mul"
+    for i = 1:REPEAT
+      c = a .* b;
+    endfor
+  case "matmul"
+    for i = 1:REPEAT
+      c = a * b;
+    endfor
+    #size(c)
+  case "solve"
+    for i = 1:REPEAT
+      c = a \ b;
+    endfor
+    #size(c)
+endswitch
+[t2, u2, s2] = cputime ();
+
+printf ("Octave type=%s size=%d op=%s repeat=%d  Time: %.2f sec", 
+	TYPE,ARRSZ,OP,REPEAT,u2 - u1);

data/src/bench/bench.py

@@ -0,0 +1,89 @@
+import time
+import sys
+
+MODULE = sys.argv[1]
+TYPE   = sys.argv[2]
+OP     = sys.argv[3]
+ARRSZ  = int(sys.argv[4])
+REPEAT = int(sys.argv[5])
+
+if MODULE=="numeric":
+    from Numeric import *
+    from LinearAlgebra import *
+elif MODULE=="numarray":
+    from numarray import *
+    from LinearAlgebra import *
+elif MODULE=="numpy":
+    from numpy import *
+    from numpy.linalg import solve
+
+def bench_time(func,repeat=REPEAT):
+  start = time.clock()
+  for i in range(repeat):
+    c = func()
+    stop = time.clock()
+  print "Python %s type=%s size=%d op=%s repeat=%d  Time: %.2f sec" % \
+      (MODULE,TYPE,ARRSZ,OP,REPEAT,stop-start)
+  #print shape(c)
+
+n = ARRSZ
+
+if MODULE=="numpy":
+    def bench_array(type=float):
+        return arange(ARRSZ,dtype=type)
+    
+    if TYPE=="float":
+        a = bench_array(float)
+        b = bench_array(float)
+    elif TYPE=="int":
+        a = bench_array(int)
+        b = bench_array(int)
+    elif TYPE=="complex":
+        a = bench_array(complex)
+        b = bench_array(complex)
+    elif TYPE=="float_cross":
+        a = reshape(arange(ARRSZ,dtype=float),(ARRSZ,1))
+        b = reshape(arange(ARRSZ,dtype=float),(1,ARRSZ))
+    elif TYPE=="float_matrix":
+        a = reshape(arange(ARRSZ**2,dtype=float),(ARRSZ,ARRSZ))
+        b = reshape(arange(ARRSZ**2,dtype=float),(ARRSZ,ARRSZ))
+    elif TYPE=="float_solve":
+        a = reshape(arange(n**2,dtype=float)%(n+1)+1,(n,n))
+        b = reshape(arange(n**2,dtype=float)+1,(n,n))
+else:
+    def bench_array(type=float):
+        return arrayrange(ARRSZ).astype(type)
+    if TYPE=="float":
+        a = bench_array(Float64)
+        b = bench_array(Float64)
+    elif TYPE=="int":
+        a = bench_array(Int32)
+        b = bench_array(Int32)
+    elif TYPE=="complex":
+        a = bench_array(Complex64)
+        b = bench_array(Complex64)
+    elif TYPE=="float_cross":
+        a = reshape(arrayrange(ARRSZ),(ARRSZ,1)).astype(Float64)
+        b = reshape(arrayrange(ARRSZ),(1,ARRSZ)).astype(Float64)
+    elif TYPE=="float_matrix":
+        a = reshape(arrayrange(ARRSZ**2),(ARRSZ,ARRSZ)).astype(Float64)
+        b = reshape(arrayrange(ARRSZ**2),(ARRSZ,ARRSZ)).astype(Float64)
+    elif TYPE=="float_solve":
+        a = reshape(arrayrange(n*n)%(n+1)+1,(n,n)).astype(Float64)
+        b = reshape(arrayrange(n*n)+1,(n,n)).astype(Float64)
+    dot = matrixmultiply
+    solve = solve_linear_equations
+
+def lambda_add(a=a,b=b):    c = a+b; return c;
+def lambda_mul(a=a,b=b):    c = a*b; return c;
+def lambda_matmul(a=a,b=b): c = dot(a,b); return c;
+def lambda_solve(a=a,b=b):  c = solve(a,b); return c;
+
+if OP=="add":
+    bench_time(lambda_add)
+elif OP=="mul":
+    bench_time(lambda_mul)
+elif OP=="matmul":
+    bench_time(lambda_matmul)
+elif OP=="solve":
+    bench_time(lambda_solve)

data/src/bench/bench.rb

@@ -0,0 +1,59 @@
+require 'narray'
+T = (RUBY_VERSION<"1.8.0") ? Time : Process
+
+TYPE   = ARGV[0]
+OP     = ARGV[1]
+ARRSZ  = Integer(ARGV[2])
+REPEAT = Integer(ARGV[3])
+
+def bench_array(type=Float)
+  [ NArray.new(type,ARRSZ).indgen!,
+    NArray.new(type,ARRSZ).indgen!  ]
+end
+
+def bench_time(n=REPEAT)
+  t1 = T.times.utime
+   for i in 1..n
+     yield
+   end
+  t = T.times.utime - t1
+  printf "Ruby NArray type=%s size=%d op=%s repeat=%d  Time: %.2f sec\n",
+    TYPE,ARRSZ,OP,REPEAT,t
+end
+
+n = ARRSZ
+
+case TYPE
+when "float"
+  a,b = bench_array(Float)
+when "int"
+  a,b = bench_array(Integer)
+when "complex"
+  a,b = bench_array(Complex)
+when "float_cross"
+  a = NArray.float(n,1).indgen!
+  b = NArray.float(1,n).indgen!
+when "float_matrix"
+  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
+when "float_solve"
+  a = NMatrix.float(n,n).indgen!(1).transpose
+  b = NArray.float(n,n).indgen!
+  b = b % (n+1) + 1
+  b = NMatrix.ref(b).transpose
+end
+
+c = 0
+
+case OP
+when "add"
+  bench_time{ c = a+b }
+when "mul"
+  bench_time{ c = a*b }
+when "solve"
+  bench_time{ c = a/b }
+end