narray-ruby19 0.5.9.7-x86-mingw32

data/lib/narray.h

@@ -0,0 +1,186 @@
+/*
+  narray.h
+  Numerical Array Extention for Ruby
+    (C) Copyright 1999-2008 by Masahiro TANAKA
+
+  This program is free software.
+  You can distribute/modify this program
+  under the same terms as Ruby itself.
+  NO WARRANTY.
+*/
+#ifndef NARRAY_H
+#define NARRAY_H
+
+#include <math.h>
+
+#include "narray_config.h"
+
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#define NARRAY_VERSION "0.5.9p7"
+#define NARRAY_VERSION_CODE 597
+
+/*
+  Data types used in NArray :
+  Please modify these types if your system has any different type.
+*/
+
+
+/* NA_BYTE : unsigned 8-bit integer */
+#ifndef HAVE_U_INT8_T
+# ifdef HAVE_UINT8_T
+typedef uint8_t			u_int8_t;
+# else
+typedef unsigned char		u_int8_t;
+# endif
+#endif
+
+#ifndef HAVE_INT16_T
+# if SIZEOF_SHORT == 2
+typedef short                  int16_t;  /* NA_SINT */
+# else
+---->> Please define int16_t manually because sizeof(short) != 2. <<----
+# endif
+#endif /* HAVE_INT16_T */
+
+#ifndef HAVE_INT32_T
+# if SIZEOF_LONG == 4
+typedef long                   int32_t;  /* NA_LINT */
+# else
+#  if SIZEOF_INT == 4
+typedef int                    int32_t;  /* NA_LINT */
+#  else
+---->> Please define int32_t manually because sizeof(long) != 4. <<----
+#  endif
+# endif
+#endif /* HAVE_INT32_T */
+
+/* unsigned 32-bit integer */
+#ifndef HAVE_U_INT32_T
+# ifdef HAVE_UINT32_T
+typedef uint32_t			u_int32_t;
+# else
+#  if SIZEOF_LONG == 4
+typedef unsigned long                   u_int32_t;  
+#  else
+#   if SIZEOF_INT == 4
+typedef unsigned int                    u_int32_t;
+#   else
+---->> Please define u_int32_t manually because sizeof(long) != 4. <<----
+#   endif
+#  endif
+# endif
+#endif /* HAVE_U_INT32_T */
+
+typedef struct { float r,i; }  scomplex;
+typedef struct { double r,i; } dcomplex;
+
+enum NArray_Types {
+  NA_NONE,
+  NA_BYTE,	/* 1 */
+  NA_SINT,	/* 2 */
+  NA_LINT,	/* 3 */
+  NA_SFLOAT,	/* 4 */
+  NA_DFLOAT,	/* 5 */
+  NA_SCOMPLEX,	/* 6 */
+  NA_DCOMPLEX,	/* 7 */
+  NA_ROBJ,	/* 8 */
+  NA_NTYPES	/* 9 */
+};
+
+/* struct for Numerical Array */
+struct NARRAY {
+  int    rank;	  /* # of dimension */
+  int    total;	  /* # of total element */
+  int    type;	  /* data type */
+  int   *shape;
+  char  *ptr;	  /* pointer to data */
+  VALUE  ref;	  /* NArray object wrapping this structure */
+};
+
+#ifndef NARRAY_C
+extern VALUE cNArray;
+
+extern const int na_sizeof[NA_NTYPES+1];
+#endif
+
+#define NA_MAX_RANK 15
+
+#define GetNArray(obj,var)  Data_Get_Struct(obj, struct NARRAY, var)
+#define IsNArray(obj) (rb_obj_is_kind_of(obj,cNArray)==Qtrue)
+
+#define NA_PTR(a,p)    ((a)->ptr+(p)*na_sizeof[(a)->type])
+#define NA_STRUCT(val) ((struct NARRAY*)DATA_PTR(val))
+#define NA_PTR_TYPE(val,type) (type)(((struct NARRAY*)DATA_PTR(val))->ptr)
+#define NA_RANK(val)   (((struct NARRAY*)DATA_PTR(val))->rank)
+#define NA_TYPE(val)   (((struct NARRAY*)DATA_PTR(val))->type)
+#define NA_TOTAL(val)  (((struct NARRAY*)DATA_PTR(val))->total)
+#define NA_SHAPE0(val) (((struct NARRAY*)DATA_PTR(val))->shape[0])
+#define NA_SHAPE1(val) (((struct NARRAY*)DATA_PTR(val))->shape[1])
+
+#define NA_IsNArray(obj) \
+  (rb_obj_is_kind_of(obj,cNArray)==Qtrue)
+#define NA_IsArray(obj) \
+  (TYPE(obj)==T_ARRAY || rb_obj_is_kind_of(obj,cNArray)==Qtrue)
+#define NA_IsROBJ(d) ((d)->type==NA_ROBJ)
+#define NA_IsINTEGER(a) \
+  ((a)->type==NA_BYTE || (a)->type==NA_SINT || (a)->type==NA_LINT )
+#define NA_IsCOMPLEX(a) \
+  ((a)->type==NA_SCOMPLEX || (a)->type==NA_DCOMPLEX)
+#define NA_MAX(a,b) (((a)>(b))?(a):(b))
+#define NA_SWAP(a,b,tmp) {(tmp)=(a);(a)=(b);(b)=(tmp);}
+
+#define na_class_dim(klass) NUM2INT(rb_const_get(klass, na_id_class_dim))
+
+#define NUM2REAL(v)  NUM2DBL( rb_funcall((v),na_id_real,0) )
+#define NUM2IMAG(v)  NUM2DBL( rb_funcall((v),na_id_imag,0) )
+
+#define NA_ALLOC_SLICE(slc,nc,shp,np) \
+{ slc = (struct slice*)xmalloc( sizeof(struct slice)*(nc) + \
+				sizeof(int)*(np) );\
+  shp = (int*)&( (slc)[nc] ); }
+
+
+/* Function Prototypes */
+
+/* narray.c */
+VALUE na_make_object(int type, int rank, int *shape, VALUE klass);
+VALUE na_make_scalar(VALUE obj, int type);
+VALUE na_make_empty(int type, VALUE klass);
+int   na_get_typecode(VALUE v);
+void  na_clear_data(struct NARRAY *ary);
+VALUE na_clone(VALUE self);
+VALUE na_fill(VALUE self, volatile VALUE obj);
+void  na_copy_nary(struct NARRAY *dst, struct NARRAY *src);
+
+/* na_array.c */
+VALUE na_to_array(VALUE obj);
+VALUE na_make_inspect(VALUE self);
+VALUE na_ary_to_nary(VALUE ary, VALUE klass);
+int   na_object_type(VALUE v);
+
+VALUE na_cast_object(VALUE obj, int type);
+VALUE na_cast_unless_narray(VALUE obj, int type);
+VALUE na_cast_unless_array(VALUE obj, int type);
+VALUE na_upcast_object(VALUE obj, int type);
+VALUE na_dup_w_type(VALUE obj, int type);
+VALUE na_change_type(VALUE obj, int type);
+VALUE na_upcast_type(VALUE obj, int type);
+VALUE na_to_narray(VALUE obj);
+
+/* na_index.c */
+VALUE na_aset(int argc, VALUE *argv, VALUE self);
+VALUE na_aref(int argc, VALUE *argv, VALUE self);
+VALUE na_slice(int argc, VALUE *argv, VALUE self);
+VALUE na_count_true(VALUE self);
+VALUE na_count_false(VALUE self);
+VALUE na_aref_mask(VALUE self, VALUE mask);
+void  na_aset_mask(VALUE self, VALUE mask, VALUE v);
+
+#endif /* ifndef NARRAY_H */

data/lib/narray_config.h

@@ -0,0 +1,5 @@
+#define HAVE_STDINT_H 1
+#define HAVE_UINT8_T 1
+#define HAVE_INT16_T 1
+#define HAVE_INT32_T 1
+#define HAVE_UINT32_T 1

data/lib/narray_ext.rb

@@ -0,0 +1,245 @@
+#  Numerical Array Extention for Ruby
+#    (C) Copyright 2000-2008 by Masahiro TANAKA
+#
+#  This program is free software.
+#  You can distribute/modify this program
+#  under the same terms as Ruby itself.
+#  NO WARRANTY.
+#
+class NArray
+
+  def integer?
+    self.typecode==NArray::BYTE ||
+    self.typecode==NArray::SINT ||
+    self.typecode==NArray::LINT
+  end
+  def complex?
+    self.typecode==NArray::DCOMPLEX ||
+    self.typecode==NArray::SCOMPLEX
+  end
+
+  def all?
+    where.size == size
+  end
+
+  def any?
+    where.size > 0
+  end
+
+  def none?
+    where.size == 0
+  end
+
+  def ==(other)
+    if other.kind_of?(NArray)
+      (shape == other.shape) && eq(other).all?
+    else
+      false
+    end
+  end
+
+  def rank_total(*ranks)
+    if ranks.size>0
+      idx = []
+      ranks.each{|i| idx.push(*i)}
+      # ranks is expected to be, e.g., [1, 3..5, 7]
+      a = self.shape
+      n = 1
+      idx.each{|i| n *= a[i]}
+      n
+    else
+      self.total
+    end
+  end
+
+# Statistics
+  def mean(*ranks)
+    if integer?
+      a = self.to_type(NArray::DFLOAT)
+    else
+      a = self
+    end
+    a = NArray.ref(a)
+    a.sum(*ranks) / (rank_total(*ranks))
+  end
+
+  def stddev(*ranks)
+    if integer?
+      a = self.to_type(NArray::DFLOAT)
+    else
+      a = self
+    end
+    a = NArray.ref(a)
+    n = rank_total(*ranks)
+    if complex?
+      NMath::sqrt( (( a-a.accum(*ranks).div!(n) ).abs**2).sum(*ranks)/(n-1) )
+    else
+      NMath::sqrt( (( a-a.accum(*ranks).div!(n) )**2).sum(*ranks)/(n-1) )
+    end
+  end
+
+  def rms(*ranks)
+    if integer?
+      a = self.to_type(NArray::DFLOAT)
+    else
+      a = self
+    end
+    a = NArray.ref(a)
+    n = rank_total(*ranks)
+    if complex?
+      NMath::sqrt( (a.abs**2).sum(*ranks)/n )
+    else
+      NMath::sqrt( (a**2).sum(*ranks)/n )
+    end
+  end
+
+  def rmsdev(*ranks)
+    if integer?
+      a = self.to_type(NArray::DFLOAT)
+    else
+      a = self
+    end
+    a = NArray.ref(a)
+    n = rank_total(*ranks)
+    if complex?
+      NMath::sqrt( (( a-a.accum(*ranks).div!(n) ).abs**2).sum(*ranks)/n )
+    else
+      NMath::sqrt( (( a-a.accum(*ranks).div!(n) )**2).sum(*ranks)/n )
+    end
+  end
+
+  def median(rank=nil)
+    shape = self.shape
+    rank = shape.size-1 if rank==nil
+    s = sort(rank).reshape!(true,*shape[rank+1..-1])
+    n = s.shape[0]
+    if n%2==1
+      s[n/2,false]
+    else
+      s[n/2-1..n/2,false].sum(0)/2
+    end
+  end
+
+
+# Normal distributed random number;  valid for floating point types
+  def randomn
+    size = self.size
+    case type = self.typecode
+    when COMPLEX; type=FLOAT
+    when SCOMPLEX; type=SFLOAT
+    when FLOAT
+    when SFLOAT
+    else
+      raise TypeError, "NArray type must be (S)FLOAT or (S)COMPLEX."
+    end
+    rr = NArray.new(type,size)
+    xx = NArray.new(type,size)
+    i = 0
+    while i < size
+      n = size-i
+      m = ((n+Math::sqrt(n))*1.27).to_i
+      x = NArray.new(type,m).random!(1) * 2 - 1
+      y = NArray.new(type,m).random!(1) * 2 - 1
+      r = x**2 + y**2
+      idx = (r<1).where
+      idx = idx[0...n] if idx.size > n
+      if idx.size>0
+	rr[i] = r[idx]
+	xx[i] = x[idx]
+	i += idx.size
+      end
+    end
+    # Box-Muller transform
+    rr = ( xx * NMath::sqrt( -2 * NMath::log(rr) / rr ) )
+    # finish
+    rr.reshape!(*self.shape) if self.rank > 1
+    rr = rr.to_type(self.typecode) if type!=self.typecode
+    if RUBY_VERSION < "1.8.0"
+      self.type.refer(rr)
+    else
+      self.class.refer(rr)
+    end
+  end
+  alias randomn! randomn
+
+  #SFloatOne = NArray.sfloat(1).fill!(1)
+end
+
+
+module NMath
+  PI = Math::PI
+  E = Math::E
+
+  def recip x
+    1/x.to_f
+  end
+
+# Trigonometric function
+  def csc x
+    1/sin(x)
+  end
+  def csch x
+    1/sinh(x)
+  end
+  def acsc x
+    asin(1/x.to_f)
+  end
+  def acsch x
+    asinh(1/x.to_f)
+  end
+
+  def sec x
+    1/cos(x)
+  end
+  def sech x
+    1/cosh(x)
+  end
+  def asec x
+    acos(1/x.to_f)
+  end
+  def asech x
+    acosh(1/x.to_f)
+  end
+
+  def cot x
+    1/tan(x)
+  end
+  def coth x
+    1/atanh(x)
+  end
+  def acot x
+    atan(1/x.to_f)
+  end
+  def acoth x
+    atanh(1/x.to_f)
+  end
+
+# Statistics
+  def covariance(x,y,*ranks)
+    x = NArray.to_na(x) unless x.kind_of?(NArray)
+    x = x.to_type(NArray::DFLOAT) if x.integer?
+    y = NArray.to_na(y) unless y.kind_of?(NArray)
+    y = y.to_type(NArray::DFLOAT) if y.integer?
+    n = x.rank_total(*ranks)
+    xm = x.accum(*ranks).div!(n)
+    ym = y.accum(*ranks).div!(n)
+    ((x-xm)*(y-ym)).sum(*ranks) / (n-1)
+  end
+
+  module_function :csc,:sec,:cot,:csch,:sech,:coth
+  module_function :acsc,:asec,:acot,:acsch,:asech,:acoth
+  module_function :covariance
+end
+
+
+module FFTW
+  def convol(a1,a2)
+    n1x,n1y = a1.shape
+    n2x,n2y = a2.shape
+    raise "arrays must have same shape" if n1x!=n2x || n1y!=n2y 
+    (FFTW.fftw( FFTW.fftw(a1,-1) * FFTW.fftw(a2,-1), 1).real) / (n1x*n1y)
+  end
+  module_function :convol
+end
+
+require 'nmatrix'

data/lib/nmatrix.rb

@@ -0,0 +1,244 @@
+#  Numerical Array Extention for Ruby
+#    (C) Copyright 2000-2003 by Masahiro TANAKA
+#
+
+#
+# ------ NMatrix ------
+#
+class NMatrix < NArray
+  CLASS_DIMENSION = 2
+
+  def +(other)
+    case other
+    when NMatrix
+      return super(NArray.refer(other))
+    when NArray
+      unless other.instance_of?(NArray)
+        return other.coerce_rev( self, :+ )
+      end
+    end
+    raise TypeError,"Illegal operation: NMatrix + %s" % other.class
+  end
+
+  def -(other)
+    case other
+    when NMatrix
+      return super(NArray.refer(other))
+    when NArray
+      unless other.instance_of?(NArray)
+        return other.coerce_rev( self, :- )
+      end
+    end
+    raise TypeError,"Illegal operation: NMatrix - %s" % other.class
+  end
+
+  def *(other)
+    case other
+    when NMatrix
+      NMatrix.mul_add( NArray.refer(self).newdim!(0),other.newdim(2), 1 )
+      #NMatrix.mul_add( NArray.refer(self).newdim!(0),
+      #		       other.transpose(1,0).newdim!(2), 0 )
+    when NVector
+      NVector.mul_add( NArray.refer(self), other.newdim(1), 0 )
+    when NArray
+      if other.instance_of?(NArray)
+	NMatrix.mul( NArray.refer(self), other.newdim(0,0) )
+      else
+	other.coerce_rev( self, :* )
+      end
+    when Numeric
+      super
+      #NMatrix.mul( NArray.refer(self), other )
+    when Array
+      NMatrix.mul( self, NArray[*other].newdim!(0,0) )
+    else
+      raise TypeError,"Illegal operation: NMatrix * %s" % other.class
+    end
+  end
+
+  def /(other)
+    case other
+    when NMatrix
+      other.lu.solve(self)
+    when NVector
+      raise TypeError,"Illegal operation: NMatrix / %s" % other.class
+    when NArray
+      if other.instance_of?(NArray)
+	NMatrix.div( NArray.refer(self), other.newdim(0,0) )
+      else
+	other.coerce_rev( self, :/ )
+      end
+    when Numeric
+      NMatrix.div( NArray.refer(self), other )
+    when Array
+      NMatrix.div( self, NArray[*other].newdim!(0,0) )
+    else
+      raise TypeError,"Illegal operation: NMatrix / %s" % other.class
+    end
+  end
+
+  def **(n)
+    case n
+    when Integer
+      if n==0
+	return 1.0
+      elsif n<0
+	m = self.inverse
+	n = -n
+      else
+	m = self
+      end
+      (2..n).each{ m *= self }
+      m
+    else
+      raise TypeError,"Illegal operation: NMatrix ** %s" % other.class
+    end
+  end
+
+  def coerce_rev(other,id)
+    case id
+    when :*
+	if other.instance_of?(NArray)
+	  return NMatrix.mul( other.newdim(0,0), self )
+	end
+	if other.instance_of?(NArrayScalar)
+	  return NMatrix.mul( other.newdim(0), self )
+	end
+    when :/
+	if other.instance_of?(NArray)
+	  return NMatrix.mul( other.newdim(0,0), self.inverse )
+	end
+	if other.instance_of?(NArrayScalar)
+	  return NMatrix.mul( other.newdim(0), self.inverse )
+	end
+    end
+    raise TypeError,"Illegal operation: %s %s NMatrix" %
+      [other.class, id.id2name]
+  end
+
+  def inverse
+    self.lu.solve( NMatrix.new(self.typecode, *self.shape).fill!(0).unit )
+  end
+
+  def transpose(*arg)
+    if arg.size==0
+      super(1,0)
+    else
+      super
+    end
+  end
+
+  def diagonal!(val=1)
+    shp = self.shape
+    idx = NArray.int(shp[0..1].min).indgen! * (shp[0]+1)
+    ref = reshape(shp[0]*shp[1],true)
+    val = NArray.to_na(val)
+    raise ArgumentError, "must be 1-d array" if val.dim!=1
+    ref[idx,true] = val.newdim!(-1)
+    self
+  end
+
+  def diagonal(val)
+    self.dup.diagonal!(val)
+  end
+
+  def unit
+    diagonal!
+  end
+  alias identity unit
+  alias I unit
+
+end # class NMatrix
+
+
+#
+# ------ NVector ------
+#
+class NVector < NArray
+  CLASS_DIMENSION = 1
+
+  def +(other)
+    case other
+    when NVector
+      return super(NArray.refer(other))
+    when NArray
+      unless other.instance_of?(NArray)
+        return other.coerce_rev( self, :+ )
+      end
+    end
+    raise TypeError,"Illegal operation: NVector + %s" % other.class
+  end
+
+  def -(other)
+    case other
+    when NVector
+      return super(NArray.refer(other))
+    when NArray
+      unless other.instance_of?(NArray)
+        return other.coerce_rev( self, :- )
+      end
+    end
+    raise TypeError,"Illegal operation: NVector - %s" % other.class
+  end
+
+  def *(other)
+    case other
+    when NMatrix
+      NVector.mul_add( NArray.refer(self).newdim!(0), other, 1 )
+    when NVector
+      NArray.mul_add( NArray.refer(self), other, 0 ) # inner product
+    when NArray
+      if other.instance_of?(NArray)
+	NVector.mul( NArray.refer(self), other.newdim(0) )
+      else
+	other.coerce_rev( self, :* )
+      end
+    when Numeric
+      NVector.mul( NArray.refer(self), other )
+    else
+      raise TypeError,"Illegal operation: NVector * %s" % other.class
+    end
+  end
+
+  def /(other)
+    case other
+    when NMatrix
+      other.lu.solve(self)
+    when NVector
+      raise TypeError,"Illegal operation: NVector / %s" % other.class
+    when NArray
+      if other.instance_of?(NArray)
+	NVector.div( NArray.refer(self), other.newdim(0) )
+      else
+	other.coerce_rev( self, :/ )
+      end
+    when Numeric
+      NVector.div( NArray.refer(self), other )
+    else
+      raise TypeError,"Illegal operation: NVector / %s" % other.class
+    end
+  end
+
+  def **(n)
+    if n==2
+      self*self
+    else
+      raise ArgumentError,"Only v**2 is implemented"
+    end
+  end
+
+  def coerce_rev(other,id)
+    case id
+    when :*
+	if other.instance_of?(NArray)
+	  return NVector.mul( other.newdim(0), self )
+	end
+	if other.instance_of?(NArrayScalar)
+	  return NVector.mul( other, self )
+	end
+    end
+    raise TypeError,"Illegal operation: %s %s NVector" %
+      [other.class, id.id2name]
+  end
+
+end # class NVector

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: narray-ruby19
+version: !ruby/object:Gem::Version 
+  version: 0.5.9.7
+platform: x86-mingw32
+authors: 
+- Masahiro Tanaka
+autorequire: 
+bindir: bin
+cert_chain: 
+date: 2009-08-15 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: 
+email: masa16.tanaka@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/narray_ext.rb
+- lib/nmatrix.rb
+- lib/narray.so
+- lib/libnarray.a
+- lib/narray.h
+- lib/narray_config.h
+has_rdoc: true
+homepage: http://narray.rubyforge.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: narray
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 1
+summary: N-dimensional Numerical Array class for Ruby
+test_files: []
+