narray 0.5.9.4

data/src/README.en

@@ -0,0 +1,54 @@
+	Ruby/NArray  ver 0.5.9 (2006-08-09)	by Masahiro TANAKA
+
+* NArray properties:
+
+  + Fast and easy calculation for large numerical array.
+  + Accepting Elements:
+    8,16,32 bit integer, single/double float/complex, Ruby Object.
+  + Easy extraction/substitution of array subset,
+    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.
+
+* NArray is similar to:
+
+  + Python/NumPy, Perl/PDL, Yorick, IDL 
+
+* NArray is far from completed!
+
+  + Experimental!  Specification may be changed.
+  + Far from completed.
+  + Bugs may be included.
+  + No document.
+
+* Installation
+
+  + If you want to use FFTW, install it.
+    http://www.fftw.org/ or http://www.netlib.org/
+
+  + Compile & Install NArray
+
+    ruby extconf.rb
+    make
+    make site-install
+    (or, make install)
+
+* Tested Platform
+
+  ruby 1.8.4 (2005-12-24) [i686-linux]
+  gcc version 4.1.1 20060525 (Red Hat 4.1.1-1)
+
+* License
+
+  This program is free software.
+  You can distribute/modify this program
+  under the same terms as Ruby itself.
+  NO WARRANTY.
+
+* Author
+
+    Masahiro TANAKA <masa@ir.isas.ac.jp>

data/src/README.ja

@@ -0,0 +1,63 @@
+	Ruby/NArray  ver 0.5.9 (2006-08-09)	by Masahiro TANAKA
+
+* Ruby/NArray$B$NFCD'!#(B
+
+  + Ruby$B$G!"9bB.$J?tCM7W;;$,2DG=!#(B
+  + $BMWAG$K$O!"(B8,16,32 bit $B@0?t!"C1@:EY(B/$BG\@:EY$N<B?t(B/$BJ#AG?t!"(B
+    $B$*$h$S(B Ruby$B%*%V%8%'%/%H$r%5%]!<%H!#(B
+  + $BItJ,G[Ns$N<h=P$7!"BeF~$bMF0W!#(B
+    $BMWAG0LCV$N;XDj$K$O!"?tCM!"HO0O!"%$%s%G%C%/%9$NG[Ns$,;HMQ2DG=!#(B
+  + +,-,*,/,%,** $B$d(B $B;;=Q4X?t$N1i;;$O!"MWAG(B-$BBP(B-$BMWAG$G$*$3$J$&!#(B
+  + $BG[NsF1;N$N1i;;!&BeF~$O!"3F<!85$N%5%$%:$,F1$8$G$"$k$3$H$,I,MW!#(B
+    $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
+  + $B?tCM7W;;!&2hA|=hM}!&%G!<%?2r@O$J$II}9-$$1~MQ$,2DG=(B($B$H;W$&(B)$B!#(B
+
+* $BN`;wIJ(B
+
+  + Python/NumPy, Perl/PDL, Yorick, IDL
+
+* $BIT==J,$JE@(B
+
+  + $B%a%=%C%I$,ITB-!#(B
+  + $B%P%0=P$7$,IT==J,!#(B
+  + $B%I%-%e%a%s%H$,$J$$!#(B
+
+* $B%$%s%9%H!<%kJ}K!(B
+
+  Ruby$B$NI8=`E*$J3HD%%i%$%V%i%j$HF1$8$G$9!#%=!<%9$rE83+$7$?%G%#%l%/%H%j$G!"(B
+
+    ruby extconf.rb
+    make
+    make site-install
+    ($B$^$?$O(B make install)
+
+  $B$H<B9T$7$^$9!#(B
+
+* $BF0:n3NG'(B
+
+  ruby 1.8.4 (2005-12-24) [i686-linux]
+  gcc version 4.1.1 20060525 (Red Hat 4.1.1-1)
+
+* $BG[I[>r7o(B
+
+  Ruby$B$N%i%$%;%s%9$K=`5r$7$^$9!#(B
+
+* $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<U<-(B
+
+  $B$^$D$b$H$f$-$R$m(B $B$5$s(B $B$r$O$8$a$H$9$k(BRuby$B3+H/<T$N$_$J$5$^(B for Ruby
+
+  $B0KF#(B $B>4B'(B $B$5$s(B for MDArray
+	$B3HD%%i%$%V%i%j$N:n$jJ}$d!"(BArray$B$+$iB?<!85G[Ns$KJQ49$9$kItJ,$r(B
+	$B;29M$K$5$;$F$$$?$@$-$^$7$?!#(B
+

data/src/SPEC.en

@@ -0,0 +1,300 @@
+
+	Ruby/NArray  ver 0.5.9 (2006-08-09)	by Masahiro TANAKA
+
+
+Class method:
+    NArray.new(typecode, size, ...)	create new NArray. initialize with 0.
+
+    NArray.byte(size,...)		1 byte unsigned integer
+    NArray.sint(size,...)		2 byte signed integer
+    NArray.int(size,...)		4 byte signed integer
+    NArray.sfloat(size,...)		single precision float
+    NArray.float(size,...)		double precision float
+    NArray.scomplex(size,...)		single precision complex
+    NArray.complex(size,...)		double precision complex
+    NArray.object(size,...)		Ruby object
+				all above method initialize with 0 or nil.
+
+    NArray.to_na(array)			convert to NArray
+    NArray.to_na(string,type[,size,...])
+    NArray[...]
+      NArray[1,5,10.0]  #=>  NArray.float(3):[1.0, 5.0, 10.0]
+      NArray[1..10]     #=>  NArray.int(10):[1,2,3,4,5,6,7,8,9,10]
+
+
+Class constant:
+    CLASS_DIMENSION	# of dimension treated as data.
+			0 for NArray, 1 for NVector, 2 for NMatrix.
+
+NArray information
+    self.dim		Return the dimension = the number of indices
+    self.rank		same as dim
+    self.shape		Return the array of sizes of each index
+    self.total		Return the number of total elements
+
+Slicing Array
+ - Index components:	Integer, Range, Array, true.
+ - Index order:		FORTRAN type.
+    a[ 1, 2, -1 ]	element slicing.
+			  If negative, counts backward from the end.
+			  Element-dimensions are contracted.
+    a[ 0..3, 4..1 ]	extract in the range.
+			  If the former of the range is bigger,
+			   return elements in reversed order.
+    a[ [1,3,2,4] ]	an array with the elements of the indices.
+			  If `a' has multi-dimension but, in [],
+			   single index is specified,
+			   `a' is treated as a single dimension array.
+    a[ 1, 2..3, [1,3,2,4], true ]   compound index.
+				    This returns 3-dim array.
+    a[]			same as a.dup.
+    a[ 0, true ]	sams as a[0,0..-1]. `true' means all.
+    a[ false, 0 ]	same as a[true,true,0], if a is a 3-d array,
+			`false' means ellipsis dimension.
+    a[ mask ]		masking. "mask" is a byte NArray with its
+			length equal to that of "a". According to the
+			value of each element of mask, the corresponding
+			element in "a" is eliminated (when 0) or
+			retained (when not 0).
+			Example: 
+				a=NArray.float(2,2).indgen!
+				p a[ a.lt 3 ]
+				--> [ 0.0, 1.0, 2.0 ]
+				(Here, a.lt 3 gives a byte NArray)
+				(This is also done by a[ (a.lt 3).where ])
+
+ - A 2-or-more-dim array object with only one argument in `[ ]',
+   is treated as a flat 1-d array.
+   e.g.: a[3] is same as a[0,1] if a is 3x3 array.
+
+ - self.slice(...)	Same as self[...] but keeps the rank of
+			original array by not elimiting dimensions 
+			whose length became equal to 1 (which self[] 
+			does). This is not the case with the
+			1-dimensional indexing and masking (same as []).
+
+Replacing Elements -- Same rule as slicing
+
+    a[ 1, 2, 3 ] = 1
+    a[ 0..3, 1..4, 2..5 ] = 2
+    a[ [1,3,2,4], true ] = 3
+    a[] = 4			Same as a.fill!(4)
+  
+    a[0..2]  = b[1..5]		--> Error! due to different num of elements.
+    a[1,2]   = b[0..2,1..3]	Storing elements from index [1,2]
+				( a[1,2]=b[0,1],a[2,2]=b[1,1],... )
+    a[0..2,0..3]  = b[0..2,1]	Storing repetitively
+				( a[0,0]=b[0,1],..,a[0,3]=b[0,1] )
+
+Filling values
+    self.indgen!([start[,step]]) Generate index;
+				 Set values from 'start' with 'step' increment
+    self.fill!(value)		 Fill elements with 'value'
+    self.random!(max)		 Set random values between 0<=x<max
+				 using MT19337
+    self.randomn		 Set Normally distributed random values
+				 with mean=0, dispersion=1 (Box-Muller)
+    NArray.srand([seed])	 Set random seed.
+				 A time-depend seed is choosed if omitted.
+
+Operation: performed element by element
+    a = NArray.float(3,3).indgen
+    b = NArray.float(3,3).fill(10)
+    c = a*b	# --> NArray.float(3,3)
+
+    a = NArray.float(3,1).indgen
+    b = NArray.float(1,3).fill(10)
+    c = a*b	# --> NArray.float(3,3) -- size=1 dimension is extensible.
+
+Arithmetic operator
+    -self
+    self + other
+    self - other
+    self * other
+    self / other
+    self % other
+    self ** other
+    self.abs
+
+    self.add! other
+    self.sbt! other
+    self.mul! other
+    self.div! other
+    self.mod! other
+
+Bitwise operator (only for integers)
+    ~self
+    self & other
+    self | other
+    self ^ other
+
+Comparison
+  -- element-wise comparison, results in BYTE-type NArray;
+     Note that not true nor false is returned.
+    self.eq other  ( == operator was obsolete after ver 0.5.4 )
+    self.ne other
+    self.gt other
+    self >  other
+    self.ge other
+    self >= other
+    self.lt other
+    self <  other 
+    self.le other
+    self <= other 
+
+    self.and other  element-wise condition.
+    self.or  other
+    self.xor other
+    self.not other
+
+    self.all?	  true if all the elements are true.
+    self.any?	  true if any element is true.
+    self.none?	  true if none of the element is true.
+    self.where	  Return NArray of indices where elements are true.
+    self.where2	  Return Array including two NArrays of indices,
+		  where elements are true and false, respectively.
+
+	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.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_index(dim)  Return index of Sort result.
+			     self[self.sort_index] equals to self.sort.
+
+Transpose
+    self.transpose( dim0, dim1, .. )
+	Transpose array.
+	The dim0-th dimension goes to the 0-th dimension of new array.
+	Negative number counts backward.
+	transpose(-1,1..-2,0) is replacement between the first and the last.
+
+Changing Shapes of indices
+    self.reshape!(size,...)
+    self.shape=(size,...)
+    self.newdim=(dim)	    Insert new dimension with size=1
+
+Reference to another NArray
+    self.refer			create NArray obj referring to another NArray
+    self.reshape(size,...)	same as self.refer.reshape!
+    self.newdim(dim,...)	same as self.refer.newdim!
+
+Type conversion
+    self.floor      Return integer NArray whose elements processed 'floor'
+    self.ceil
+    self.round
+    self.to_f	    Convert NArray type to float
+    self.to_i       Convert NArray type to integer
+    self.to_a	    Convert NArray type to Ruby-object
+    self.to_s	    Convert NArray data to String as a binary data.
+    self.to_string  Convert NArray type to Ruby-object
+		    containing Strings as printed elements
+
+Iteration
+    self.each {|i| ...}
+    self.collect {|i| ...}
+    self.collect! {|i| ...}
+
+Byte swap
+    self.swap_byte	swap byte order
+    self.hton		convert to network byte order
+    self.ntoh		
+    self.htov		convert to VAX byte order
+    self.vtoh		
+
+Boolean / mask related
+    self.count_false	count # of elements whose value == 0 (only for
+			byte, sint, and int)
+    self.count_true	count # of elements whose value != 0 (only for
+			byte, sint, and int)
+    self.mask( mask )	same as self[ mask ], but exclusively for masking.
+			Unlike [], a int or sint mask is accepted.
+
+Complex compound number
+    self.real
+    self.imag
+    self.conj
+    self.angle		atan2(self.imag, self.real)
+    self.imag= other	set imaginary part
+    self.im		multiply by imaginary unit
+
+NMath module
+    sqrt(x)
+    exp(x)
+    log(x)
+    log10(x)
+    log2(x)
+    atan2(x,y)
+    sin,cos,tan
+    sinh,cosh,tanh
+    asin,acos,atan
+    asinh,acosh,atanh
+    csc,sec,cot
+    csch,sech,coth
+    acsc,asec,acot
+    acsch,asech,acoth
+    covariance	(no idea why NMath::covariance doesn't work)
+
+
+FFTW module
+ (separate module)
+    fftw(x,[1|-1])
+    convol(a,b)		convolution with FFTW
+
+
+NMatrix
+
+  Subclass of NArray.  First 2 dimensions are used as Matrix.
+  Residual dimensions are treated as Multi-dimensional array.
+  The order of Matrix dimensions is opposite from
+  the notation of mathematics:  a_ij => a[j,i]
+
+  Methods:
+    +,-	 enable if other is NMatrix.
+    *	 Matrix product if other is NMatrix or NVector.
+	 Scalar product if other is Numeric or NArray.
+	 ex: NMatrix[[1,2],[3,4]] * [1,10]
+	       == NMatrix[ [[1,2],[3,4]], [[10,20],[30,40]] ]
+    /	 Scalar division if other is Numeric or NArray.
+	 Solve Linear Equation with LU factorization
+	  if other is square NMatrix.  a/b == b.lu.solve(a)
+
+    transpose		transpose Matrix dimensions if argument omitted.
+    diagonal(val)
+    diagonal!(val)	set val to diagonal elements. (set 1 if omitted)
+    unit		set 1 to diagonal elements.
+    inverse		Inverse matrix.
+    lu			compute LU factorization.
+			return NMatrixLU class object.
+
+NVector
+
+  Subclass of NArray.  First 1 dimension is used as Vector.
+  Residual dimensions are treated as Multi-dimensional array.
+
+  Methods:
+    +,-	 enable if other is NVector.
+    *	 Matrix product if other is NMatrix.
+	 Inner product if other is NVector.
+	 Scalar product if other is Numeric or NArray.
+    /	 Scalar division if other is Numeric or NArray.
+	 Solve Linear Equation with LU factorization
+	   if other is square NMatrix.  v/m == m.lu.solve(v)
+
+
+NMatrixLU
+
+  Created by NMatrix#lu method.
+  Including LU (NMatrix) and pivot (NVector).
+
+  Methods:
+    solve(other)	Solve with the result of LU factorization.
+			other should be NMatrix or NVector instance.

data/src/SPEC.ja

@@ -0,0 +1,284 @@
+
+	Ruby/NArray  ver 0.5.9 (2006-08-09)	by Masahiro TANAKA
+
+
+$B%/%i%9%a%=%C%I(B:
+    NArray.new(typecode, size, ...)	$BG[Ns$r@8@.$9$k!#MWAG$O(B0$B$G=i4|2=!#(B
+
+    NArray.byte(size,...)		1 byte unsigned integer
+    NArray.sint(size,...)		2 byte signed integer
+    NArray.int(size,...)		4 byte signed integer
+    NArray.sfloat(size,...)		single precision float
+    NArray.float(size,...)		double precision float
+    NArray.scomplex(size,...)		single precision complex
+    NArray.complex(size,...)		double precision complex
+    NArray.object(size,...)		Ruby object
+					$B0J>eMWAG$O(B0$B$^$?$O(Bnil$B$G=i4|2=!#(B
+
+    NArray.to_na(array)			NArray$B$KJQ49(B
+    NArray.to_na(string,type[,size,..])
+    NArray[...]
+      NArray[1,5,10.0]  #=>  NArray.float(3):[1.0, 5.0, 10.0]
+      NArray[1..10]     #=>  NArray.int(10):[1,2,3,4,5,6,7,8,9,10]
+
+
+$B%/%i%9JQ?t(B:
+    CLASS_DIMENSION	$B%G!<%?$H$7$F07$o$l$k<!85!#(B
+			NArray$B$O(B0$B!#(BNVector$B$O(B1$B!#(BNMatrix$B$O(B2$B!#(B
+
+$BG[Ns>pJs;2>H(B
+    self.dim	    $B<!85(B($B%$%s%G%C%/%9$N?t(B)$B$rJV$9!#(B
+    self.rank	    $B<!85(B($B%$%s%G%C%/%9$N?t(B)$B$rJV$9!#(B
+    self.shape	    $B<!85$4$H$N%5%$%:$rJV$9!#(B
+    self.total	    $BA4MWAG?t$rJV$9!#(B
+
+$B%$%s%G%C%/%9;2>H(B
+    self[ dim0, dim1, ... ]
+
+  -- $B%$%s%G%C%/%90z?t$K;XDj$G$-$k$b$N(B:  $B?tCM!"HO0O!"G[Ns!"(Btrue, false
+  -- $B%$%s%G%C%/%9$N=g=x(B:		FORTRAN $B7?(B
+  -- $BE:;z0z?t$,(B1$B$D$N>l9g!"B?<!85G[Ns$O(Bflatten$B$5$l$?(B1$B<!85G[Ns$H$_$J$5$l$k!#(B
+     $BNc(B: a $B$,(B 3x3 $BG[Ns$N$H$-!"(Ba[3] $B$O(B a[0,1] $B$NMWAG$r;X$9!#(B
+
+    a[ 1, 2, -1 ]	$BMWAG$N<h$j=P$7!#Ii?t$O:G8e$+$i?t$($k(B(-1$B$,:G8e(B)
+			$BMWAG;XDj$N<!85$O=LLs$5$l$k!#(B
+    a[ 0..3, 4..1 ]	$BHO0O<h$j=P$7!#HO0O$N:G8e$,:G=i$h$jA0$J$i$P5U=g$K$J$k!#(B
+    a[ [1,4,2] ]	$B%$%s%G%C%/%9G[Ns!#MWAG$,(B[a[1],a[4],a[2]]$B$N(BNArray$B$,JV$k!#(B
+    a[]			a.dup $B$HF1$8!#(B
+    a[ 0, true ]	a[0, 0..-1] $B$HF1$8!#(B
+    a[ 0, false ]	a$B$,(B3$B<!85$N$H$-!"(Ba[0,true,true] $B$HF1$8!#(B
+			$B>JN,$5$l$?<!85$9$Y$F$K(Btrue$B$r;XDj$7$?$N$HF1$8!#(B
+    a[ mask ]		$B%^%9%-%s%0(B. mask $B$OD9$5$,(B a $B$HEy$7$$(B byte $B7?(B 
+			NArray. mask $B$N3FMWAG$NCM$K1~$8$F!"(Ba $B$N$=$l$>(B
+			$B$l$OMn$5$l$k(B(0$B$N>l9g(B)$B$+!"J];}$5$l$k(B(0$B0J30$N>l9g(B)$B!#(B
+			$BNc(B: 
+				a=NArray.float(2,2).indgen!
+				p a[ a.lt 3 ]
+				--> [ 0.0, 1.0, 2.0 ]
+				(a.lt 3 $B$O(B byte $B7?(B NArray $B$rJV$9(B)
+				($BF1$8$3$H$O(B a[ (a.lt 3).where ] $B$G$b=PMh$k(B)
+
+  -- self.slice(...)	self[...] $B$HF1$8$@$,!"D9$5$,#1$K$J$C$?<!85$rMn(B
+			$B$5$:(B(self[]$B$OMn$9(B)$B!"$b$H$N%i%s%/$rJ]$D!#C"$7!"(B
+			1$B<!85%$%s%G%C%/%9IU$1$H%^%9%-%s%0$ONc30(B([]$B$HF1(B
+			$B$8(B)$B!#(B
+
+$B%$%s%G%C%/%9BeF~!#(B-- $B<h=P$7$H$[$\F1$8%k!<%k!#(B
+
+    a[ 1, 2, 3 ] = 1
+    a[ 0..3, 1..4, 2..5 ] = 2
+    a[ [1,3,2,4], true ] = 3
+    a[] = 4			a.fill!(4) $B$HF1$8!#(B
+  
+    a[0..2]  = b[1..5]		--> $BMWAG?t$,0[$J$k$N$G%(%i!<!#(B
+    a[1,2]   = b[0..2,1..3]	[1,2]$B$r;OE@$H$7$FBeF~!#(B
+    a[0..2,0..3]  = b[0..2,1]	$B7+$jJV$7BeF~!#(B
+				( a[0,0]=b[0,1],..,a[0,3]=b[0,1] )
+
+$BCM$N%;%C%H!#(B
+    self.indgen!([start[,step]]) start$B$+$i(Bstep$B$E$DA}2C$7$?CM$r%;%C%H!#(B
+    self.fill!(value)		 $B$9$Y$F$NMWAG$K(Bvalue$B$r%;%C%H!#(B
+    self.random!(max)		 0<=x<max $B$N0lMM$J%i%s%@%`CM$r@8@.!#(B
+				 using MT19337
+    self.randomn		 $BJ?6Q(B0$B!"J,;6(B1$B$N@55,J,I[$N%i%s%@%`CM$r@8@.!#(B
+				 (Box-Muller)
+    NArray.srand([seed])	 $BMp?t$N%7!<%I$r@_Dj!#(B
+				 $B>JN,;~$O;~9o$+$i<+F0@8@.!#(B
+
+$B1i;;(B: $BMWAG$4$H$K$*$3$J$&!#(B
+    a = NArray.float(3,3).indgen
+    b = NArray.float(3,3).fill(10)
+    c = a*b	# --> NArray.float(3,3)
+
+    a = NArray.float(3,1).indgen
+    b = NArray.float(1,3).fill(10)
+    c = a*b	# --> NArray.float(3,3) -- size=1$B$N<!85$O3HD%$9$k!#(B
+
+$B;;=Q1i;;;R(B
+    -self
+    self + other
+    self - other
+    self * other
+    self / other
+    self % other
+    self ** other
+    self.abs
+
+    self.add! other
+    self.sbt! other
+    self.mul! other
+    self.div! other
+    self.mod! other
+
+    self.mul_add(other,dim,...)   (self * other).sum(dim,...)$B$H$[$\F1$8!#(B
+				  $B$?$@$7ESCf$GG[Ns$r:n$i$J$$!#(B
+
+$B%S%C%H1i;;;R(B($B@0?t$N$_2DG=(B)
+    ~self
+    self & other
+    self | other
+    self ^ other
+
+$BHf3S(B
+  -- $BMWAG$4$H$KCM$rHf3S$7!"7k2L$r(BBYTE$B7?(B NArray$B$rJV$9!#(B
+     true/false$B$G$J$$$3$H$KCm0U!#(B
+    self.eq other  ( ver 0.5.4 $B0J9_!"(B== $B1i;;;R$OGQ;_$7$^$7$?!#(B)
+    self.ne other
+    self.gt other
+    self >  other
+    self.ge other
+    self >= other
+    self.lt other
+    self <  other 
+    self.le other
+    self <= other
+
+    self.and other  $BMWAG$4$H$N>r7oHf3S!#(B
+    self.or  other
+    self.xor other
+    self.not other
+
+    self.all?     $BMWAG$,$9$Y$F??$J$i$P??!#(B
+    self.any?     $BMWAG$N$I$l$+$,??$J$i$P??!#(B
+    self.none?    $BMWAG$N$I$l$+$,??$J$i$P??!#(B
+    self.where	  $BMWAG$,??$N%$%s%G%C%/%9G[Ns$rJV$9!#(B
+    self.where2	  $BMWAG$,??$H56$N%$%s%G%C%/%9G[Ns$r4^$`(B(Ruby)$BG[Ns$rJV$9!#(B
+
+	$BNc(B: idx_t,idx_f = (a>12).where2
+
+$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.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)
+    self.median(dim)	    0..dim$B$N<!85$NCf1{CM!#>JN,;~$O$9$Y$F$N<!85!#(B
+
+$B%=!<%H(B
+    self.sort(dim)	     0..dim$B$N<!85$G%=!<%H!#>JN,;~$O$9$Y$F$N<!85!#(B
+    self.sort_index(dim)     $B%=!<%H$7$?%$%s%G%C%/%9$rJV$9!#(B
+			     self[self.sort_index] $B$O(B self.sort $B$HF1Ey!#(B
+
+$BE>CV(B
+    self.transpose( dim0, dim1, .. )
+	$BG[Ns$NE>CV!#(Bself$B$NBh(B(dim0)$B<!85$,?7$7$$G[Ns$NBh(B0$B<!85$K$J$k!#(B
+	$BIi?t$O8e$+$i$N=gHV!#(B
+	transpose(-1,1..-2,0) $B$G:G=i$H:G8e$rF~$l49$(!#(B
+
+$B%$%s%G%C%/%9$NJQ99(B ($BMWAG?t$OITJQ(B)
+    self.reshape!(size,...)
+    self.shape= size,...
+    self.newdim!(dim,...)	$B;XDj0LCV$K%5%$%:(B1$B$N<!85$rA^F~$9$k!#(B
+
+$B%G!<%?$N;2>H(B
+    self.refer			self$B$N%G!<%?$r;2>H$9$kJL$N%*%V%8%'%/%H$r:n@.!#(B
+    self.reshape(size,...)	self.refer.reshape! $B$HF1MM!#(B
+    self.newdim(dim,...)	self.refer.newdim! $B$HF1MM!#(B
+
+$B7?JQ49(B
+    self.floor self$B$h$j>.$5$$:GBg$N@0?t$rJV$9!#(B
+    self.ceil  self$B$h$jBg$-$$:G>.$N@0?t$rJV$9!#(B
+    self.round self$B$K$b$C$H$b6a$$@0?t$rJV$9!#(B
+    self.to_f  $BCM$rIbF0>.?tE@?t$KJQ49$9$k!#(B
+    self.to_i  $BCM$r@0?t$KJQ49$9$k!#(B 
+    self.to_a  $BCM$r(BRuby$B$NG[Ns$KJQ49$9$k!#(B
+    self.to_s  $B%P%$%J%j%G!<%?$r$=$N$^$^(BRuby$B$NJ8;zNs%G!<%?$KJQ49$9$k!#(B
+    self.to_string  $B3FMWAG$rJ8;zNs$KJQ49$9$k!#(B
+
+$B%$%F%l!<%?(B
+    self.each {|i| ...}
+    self.collect {|i| ...}
+    self.collect! {|i| ...}
+
+$B%P%$%H%9%o%C%W(B
+    self.swap_byte	$B%P%$%H%9%o%C%W(B
+    self.hton		$B%M%C%H%o!<%/%P%$%H%*!<%@!<$KJQ49(B
+    self.ntoh		
+    self.htov		VAX$B%P%$%H%*!<%@!<$KJQ49(B
+    self.vtoh		
+
+Boolean / $B%^%9%/4X78(B
+    self.count_false	$BCM(B == 0 $B$NMWAG?t(B (byte, sint, int $B$N$_(B)
+    self.count_true	$BCM(B == 1 $B$NMWAG?t(B (byte, sint, int $B$N$_(B)
+    self.mask( mask )	self[ mask ] $B$HF1$8$@$+%^%9%-%s%0@lMQ(B.
+			[] $B$H0c$$(B int, sint $B$N%^%9%/$b;H$($k(B.
+
+$BJ#AG?t(B
+    self.real
+    self.imag
+    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
+
+NMath $B%b%8%e!<%k(B
+    sqrt(x)
+    exp(x)
+    log(x)
+    log10(x)
+    log2(x)
+    atan2(x,y)
+    sin,cos,tan
+    sinh,cosh,tanh
+    asin,acos,atan
+    asinh,acosh,atanh
+    csc,sec,cot
+    csch,sech,coth
+    acsc,asec,acot
+    acsch,asech,acoth
+    covariance
+
+
+FFTW $B%b%8%e!<%k(B (fftw-2.1.3$B$r(Bshared lib$B$G%3%s%Q%$%k$7$?$b$N$G3NG'(B)
+ ($BJL%b%8%e!<%k(B)
+    fftw(x,[1|-1])
+    convol(a,b)		FFTW$B$rMQ$$$?>v$_9~$_!#(B
+
+
+NMatrix
+
+  NArray$B$N%5%V%/%i%9!#:G=i$N(B2$B<!85$r(BMatrix$B$H$7$FMQ$$$k!#(B
+  $B;D$j$N<!85$OB?<!85G[Ns$H$7$F07$o$l$k!#(B
+  $B<!85$N=g=x$O!"?t3X$G$NI=5-$H$O5U(B:  a_ij => a[j,i]
+
+  $B%a%=%C%I(B:
+    +,-	 $BAj<j$,(B NMatrix $B$N$H$-$K1i;;2D!#(B
+    *	 $BAj<j$,(B NMatrix $B$^$?$O(B NVector $B$N$H$-$O(B Matrix$B@Q!#(B
+	 $BAj<j$,(B Numeric $B$^$?$O(B NArray $B$N$H$-$O(B Scalar$B@Q!#(B
+	 $BNc(B: NMatrix[[1,2],[3,4]] * [1,10]
+	       == NMatrix[ [[1,2],[3,4]], [[10,20],[30,40]] ]
+    /	 $BAj<j$,(B Numeric $B$^$?$O(B NArray $B$N$H$-$O(BScalar$B=|;;!#(B
+	 $BAj<j$,(B square NMatrix $B$N$H$-$O(BLU$B$K$h$j@~7AJ}Dx<0$r2r$/!#(B
+	 a/b == b.lu.solve(a)
+
+    transpose		$B0z?t$r>JN,$7$?>l9g$O!":G=i$N(BMatrix$B<!85$r8r49!#(B
+    diagonal(other)
+    diagonal!(other)	$BBP3QMWAG$KCM$r%;%C%H!#0z?t>JN,;~$O(B1$B$r%;%C%H!#(B
+    I			$BBP3QMWAG$KCM$K(B1$B$r%;%C%H!#(B
+    inverse		$B5U9TNs(B
+    lu			LU$BJ,2r$r7W;;!#(BNMatrixLU $B%/%i%9$N%$%s%9%?%s%9$rJV$9!#(B
+
+
+NVector
+
+  NArray$B$N%5%V%/%i%9!#:G=i$N(B1$B<!85$r(BVector$B$H$7$FMQ$$$k!#(B
+  $B;D$j$N<!85$OB?<!85G[Ns$H$7$F07$o$l$k!#(B
+
+  $B%a%=%C%I(B:
+    +,-	 $BAj<j$,(B NVector $B$N$H$-$K1i;;2D!#(B
+    *	 $BAj<j$,(B NMatrix $B$N$H$-$O(B Matrix$B@Q!#(B
+    	 $BAj<j$,(B NVector $B$N$H$-$O(B $BFb@Q!#(B
+	 $BAj<j$,(B Numeric $B$^$?$O(B NArray $B$N$H$-$O(B Scalar$B@Q!#(B
+    /	 $BAj<j$,(B Numeric $B$^$?$O(B NArray $B$N$H$-$O(B Scalar$B=|;;!#(B
+	 $BAj<j$,(B square NMatrix $B$N$H$-$O(BLU$B$K$h$j@~7AJ}Dx<0$r2r$/!#(B
+	 v/m == m.lu.solve(v)
+
+NMatrixLU
+
+  NMatrix#lu $B%a%=%C%I$K$h$j:n$i$l$k!#(B
+  LU (NMatrix) $B$H(B pivot (NVector) $B$r4^$`!#(B
+
+  $B%a%=%C%I(B:
+    solve(other)	LU$BJ,2r$N7k2L$r;H$C$F(B other $B$r2r$/!#(B
+			other $B$O(B NMatrix $B$^$?$O(B NVector $B$N%$%s%9%?%s%9!#(B