numru-narray 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db92ba9962254a39883414ae302128af4deab214
-  data.tar.gz: 9645b05469adef3bbe09ff30ddf48ddcabdbbb38
+  metadata.gz: 245218221c00f1e210e6743a9dab4c1baf277791
+  data.tar.gz: d18efa11c4da83b5b1de3e59146c9c245d8ecd32
 SHA512:
-  metadata.gz: c5244ca52d8ebf5e0f0d9750b02ee0e91f960d2eab18c3645e52f21787f53fa47ce7d548bc97476e11c6f5b04bf4c0e076b5dc9be4ffb9ae8a7389342adcfc32
-  data.tar.gz: e463b1c0303f4e40f6d09892b45005796f173afc05ec6e4f1e463238a00541b33fd1293fab5f83b5e23f800303080ffc5cc3397341969cc4017ec54cb3ea356d
+  metadata.gz: 6222fdcaa4d98cb07714873c7c0002d701e86b35f2184125d995b59cc6539c4bb615568bb67e16b970420c885defd615a75963861a2a9fd557c4fd2db36f9703
+  data.tar.gz: cb5f9c61d30a56279a301da5051a8a15af9c05917b36371b42263dbb2540d93391f66f5a8d26c9a517038ca02f8124d605a0053318f7f54734b182d8c3008938

data/ChangeLog

@@ -1,3 +1,59 @@
+2016-02-15 Seiya Nishizawa <seiya@gfd-dennou.org>
+
+	* fixed wrong integer type in the lu solver
+
+2016-02-15 Seiya Nishizawa <seiya@gfd-dennou.org>
+
+	* fixed wrong type
+
+2016-02-15 Seiya Nishizawa <seiya@gfd-dennou.org>
+
+	* add "include NumRu" to the benchmark scripts
+
+2016-02-15 Seiya Nishizawa <seiya@gfd-dennou.org>
+
+	* enable #to_s_refer for ruby >= 1.9
+
+2016-02-14 Seiya Nishizawa <seiya@gfd-dennou.org>
+
+	* use #to_s for #to_s_refer for ruby < 2.2
+
+2016-02-13 Seiya Nishizawa <seiya@gfd-dennou.org>
+
+	* update README
+
+2016-02-13 Seiya Nishizawa <seiya@gfd-dennou.org>
+
+	* update mkmath.rb (na_math.c was overwrited)
+
+2016-02-13 Seiya Nishizawa <seiya@gfd-dennou.org>
+
+	* update tests
+
+2016-02-13 Seiya Nishizawa <seiya@gfd-dennou.org>
+
+	* add "include NumRu" to the test files
+
+2016-02-13 Seiya Nishizawa <seiya@gfd-dennou.org>
+
+	* add Gemfile file
+
+2016-02-13 Seiya Nishizawa <seiya@gfd-dennou.org>
+
+	* add travis setting
+
+2016-02-13 Seiya Nishizawa <seiya@gfd-dennou.org>
+
+	* add NumRu::NArray#to_s_refer method (same as #to_s but not dup data)
+
+2016-02-12 Seiya Nishizawa <seiya@gfd-dennou.org>
+
+	* remove narray.gemspec
+
+2016-02-12 Seiya Nishizawa <seiya@gfd-dennou.org>
+
+	* update ChangeLog
+
 2016-02-12 Seiya Nishizawa <seiya@gfd-dennou.org>
 
 	* update version

data/README

@@ -11,11 +11,14 @@
 
 * Installation
 
-  + Compile & Install NumRu NArray
+  + Install NumRu NArray
 
-    ruby extconf.rb
-    make
-    make install
+    % gem install numru-narray
+
+  + Compile (if you do not want to via gem)
+
+    % bundle install
+    % bundle exec rake compile
 
   + For OpenMP support
 
@@ -30,7 +33,7 @@
 * Run
 
   + load library
-    require 'narray'
+    require 'numru/narray'
 
   + enable OpenMP
 

data/ext/numru/narray/extconf.rb

@@ -120,4 +120,4 @@ have_type("uint64_t", header)
 $objs = srcs.collect{|i| i+".o"}
 
 create_conf_h("narray_config.h")
-create_makefile("numru/narray/narray")
+create_makefile("numru/narray")

data/ext/numru/narray/mkmath.rb

@@ -775,10 +775,10 @@ print <<EOM
 
 
 /* Initialization of NMath module */
-void Init_nmath(void)
+void Init_nmath(VALUE mNumRu)
 {
   /* define ExtMath module */
-  rb_mNMath = rb_define_module("NMath");
+  rb_mNMath = rb_define_module_under(mNumRu, "NMath");
 
   /* methods */
 EOM

data/ext/numru/narray/na_func.c

@@ -381,6 +381,7 @@ static int
   else
     rb_raise(rb_eRuntimeError, "Array size mismatch: %zd != %zd at %i-th dim",
 	     ary_sz, itr_sz, i);
+  return -1;
 }
 
 
@@ -1035,7 +1036,7 @@ static int
       r = NUM2SHAPE(v);
       if (r<0) r += rankc;     /* negative for from end */
       if (r<0 || r>=rankc)
-        rb_raise(rb_eArgError, "rank %ld out of range", r);
+        rb_raise(rb_eArgError, "rank %zd out of range", r);
       if (flag)
 	rankv[c] = r;
       else

data/ext/numru/narray/na_linalg.c

@@ -375,7 +375,7 @@ na_lu_solve_func_body( int ni,
   na_shape_t i,k;
   na_funcset_t *f = &na_funcset[type];
   na_shape_t n = shape[1];
-  int sz = na_sizeof[type];
+  na_shape_t sz = (na_shape_t) na_sizeof[type];
   na_shape_t xsz = shape[0] * sz;
   na_shape_t rowsz = sz * n;
   na_shape_t matsz = rowsz * n;

data/ext/numru/narray/narray.c

@@ -10,6 +10,7 @@
 */
 #define NARRAY_C
 #include <ruby.h>
+#include "ruby/version.h"
 #include "narray.h"
 #include "narray_local.h"
 
@@ -657,6 +658,40 @@ static VALUE
   return rb_str_new(ary->ptr,ary->total*na_sizeof[ary->type]);
 }
 
+/* method: to_s_refer -- convert the data contents to a binary string (not dup data) */
+static VALUE
+ na_to_s_refer(VALUE self)
+{
+  struct NARRAY *ary;
+  VALUE str;
+  GetNArray(self,ary);
+  if (NA_IsROBJ(ary))
+    rb_raise(rb_eTypeError,"cannot convert object-type NArray");
+#if RUBY_API_VERSION_CODE >= 20200
+  str = rb_str_new_static(ary->ptr,ary->total*na_sizeof[ary->type]);
+  RB_OBJ_WRITE(str, &RSTRING(str)->as.heap.aux.shared, self);
+  FL_SET(str, ELTS_SHARED);
+#elif RUBY_API_VERSION_CODE >= 10900
+  {
+  NEWOBJ(rstr, struct RString);
+  str = (VALUE)rstr;
+  }
+  OBJSETUP(str, rb_cString, T_STRING);
+  FL_SET(str, FL_USER1);
+  RBASIC(str)->flags &= ~RSTRING_EMBED_LEN_MASK;
+  RBASIC(str)->flags |= (0L << RSTRING_EMBED_LEN_SHIFT);
+  RSTRING(str)->as.heap.len = ary->total*na_sizeof[ary->type];
+  RSTRING(str)->as.heap.ptr = ary->ptr;
+  RSTRING(str)->as.heap.aux.capa = RSTRING(str)->as.heap.len;
+  RSTRING(str)->as.heap.aux.shared = self;
+  FL_SET(str, ELTS_SHARED);
+#else
+  str = rb_str_new(ary->ptr,ary->total*na_sizeof[ary->type]);
+  rb_warn("#to_s is used for #to_s_refer for ruby < 1.9 (%d.%d.%d)", RUBY_API_VERSION_MAJOR, RUBY_API_VERSION_MINOR, RUBY_API_VERSION_TEENY);
+#endif
+  return rb_obj_freeze(str);
+}
+
 
 /* method: to_binary -- convert the data contents to a BYTE type NArray */
 static VALUE
@@ -1264,6 +1299,7 @@ void
     rb_define_alias(cNArray, "map", "collect");
     rb_define_alias(cNArray, "map!", "collect!");
     rb_define_method(cNArray, "to_s", na_to_s, 0);
+    rb_define_method(cNArray, "to_s_refer", na_to_s_refer, 0);
     rb_define_method(cNArray, "to_f", na_to_float, 0);
     rb_define_method(cNArray, "to_i", na_to_integer, 0);
     rb_define_method(cNArray, "to_type", na_to_type, 1);

data/ext/numru/narray/narray.h

@@ -27,8 +27,8 @@
 #define NARRAY_VERSION "0.6.0.8"
 #define NARRAY_VERSION_CODE 608
 
-#define NUMRU_NARRAY_VERSION "1.0.1"
-#define NUMRU_NARRAY_VERSION_CODE 101
+#define NUMRU_NARRAY_VERSION "1.0.2"
+#define NUMRU_NARRAY_VERSION_CODE 102
 
 /* big memory support */
 #define NARRAY_BIGMEM 1

data/lib/numru/narray_ext.rb

@@ -10,11 +10,11 @@ class NumRu::NArray
 
   def self.cast(array,type=nil)
     case array
-    when NArray
+    when NumRu::NArray
     when Array
-      array = NArray.to_na(array)
+      array = NumRu::NArray.to_na(array)
     else
-      raise ArgumentError, "1st argument must be NArray or Array"
+      raise ArgumentError, "1st argument must be NumRu::NArray or Array"
     end
     type = array.typecode if type.nil?
     shape = array.shape
@@ -24,13 +24,13 @@ class NumRu::NArray
   end
 
   def integer?
-    self.typecode==NArray::BYTE ||
-    self.typecode==NArray::SINT ||
-    self.typecode==NArray::LINT
+    self.typecode==NumRu::NArray::BYTE ||
+    self.typecode==NumRu::NArray::SINT ||
+    self.typecode==NumRu::NArray::LINT
   end
   def complex?
-    self.typecode==NArray::DCOMPLEX ||
-    self.typecode==NArray::SCOMPLEX
+    self.typecode==NumRu::NArray::DCOMPLEX ||
+    self.typecode==NumRu::NArray::SCOMPLEX
   end
 
   def all?
@@ -46,7 +46,7 @@ class NumRu::NArray
   end
 
   def ==(other)
-    other.kind_of?(NArray) &&
+    other.kind_of?(NumRu::NArray) &&
       shape == other.shape && 
       eq(other).all?
   end
@@ -56,7 +56,7 @@ class NumRu::NArray
       typecode == other.typecode &&
       shape == other.shape &&
       case typecode
-      when NArray::OBJECT
+      when NumRu::NArray::OBJECT
 	to_a.eql? other.to_a
       else
 	to_s.eql? other.to_s
@@ -65,7 +65,7 @@ class NumRu::NArray
 
   def hash
     case typecode
-    when NArray::OBJECT
+    when NumRu::NArray::OBJECT
       [self.class, to_a].hash
     else
       [self.class, typecode, shape, to_s].hash
@@ -130,56 +130,56 @@ class NumRu::NArray
 # Statistics
   def mean(*ranks)
     if integer?
-      a = self.to_type(NArray::DFLOAT)
+      a = self.to_type(NumRu::NArray::DFLOAT)
     else
       a = self
     end
-    a = NArray.ref(a)
+    a = NumRu::NArray.ref(a)
     a.sum(*ranks) / (rank_total(*ranks))
   end
 
   def stddev(*ranks)
     if integer?
-      a = self.to_type(NArray::DFLOAT)
+      a = self.to_type(NumRu::NArray::DFLOAT)
     else
       a = self
     end
-    a = NArray.ref(a)
+    a = NumRu::NArray.ref(a)
     n = rank_total(*ranks)
     if complex?
-      NMath::sqrt( (( a-a.accum(*ranks).div!(n) ).abs**2).sum(*ranks)/(n-1) )
+      NumRu::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) )
+      NumRu::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)
+      a = self.to_type(NumRu::NArray::DFLOAT)
     else
       a = self
     end
-    a = NArray.ref(a)
+    a = NumRu::NArray.ref(a)
     n = rank_total(*ranks)
     if complex?
-      NMath::sqrt( (a.abs**2).sum(*ranks)/n )
+      NumRu::NMath::sqrt( (a.abs**2).sum(*ranks)/n )
     else
-      NMath::sqrt( (a**2).sum(*ranks)/n )
+      NumRu::NMath::sqrt( (a**2).sum(*ranks)/n )
     end
   end
 
   def rmsdev(*ranks)
     if integer?
-      a = self.to_type(NArray::DFLOAT)
+      a = self.to_type(NumRu::NArray::DFLOAT)
     else
       a = self
     end
-    a = NArray.ref(a)
+    a = NumRu::NArray.ref(a)
     n = rank_total(*ranks)
     if complex?
-      NMath::sqrt( (( a-a.accum(*ranks).div!(n) ).abs**2).sum(*ranks)/n )
+      NumRu::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 )
+      NumRu::NMath::sqrt( (( a-a.accum(*ranks).div!(n) )**2).sum(*ranks)/n )
     end
   end
 
@@ -205,16 +205,16 @@ class NumRu::NArray
     when FLOAT
     when SFLOAT
     else
-      raise TypeError, "NArray type must be (S)FLOAT or (S)COMPLEX."
+      raise TypeError, "NumRu::NArray type must be (S)FLOAT or (S)COMPLEX."
     end
-    rr = NArray.new(type,size)
-    xx = NArray.new(type,size)
+    rr = NumRu::NArray.new(type,size)
+    xx = NumRu::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
+      x = NumRu::NArray.new(type,m).random!(1) * 2 - 1
+      y = NumRu::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
@@ -225,7 +225,7 @@ class NumRu::NArray
       end
     end
     # Box-Muller transform
-    rr = ( xx * NMath::sqrt( -2 * NMath::log(rr) / rr ) )
+    rr = ( xx * NumRu::NMath::sqrt( -2 * NumRu::NMath::log(rr) / rr ) )
     # finish
     rr.reshape!(*self.shape) if self.rank > 1
     rr = rr.to_type(self.typecode) if type!=self.typecode
@@ -278,7 +278,7 @@ class NumRu::NArray
     end
   end
 
-  #SFloatOne = NArray.sfloat(1).fill!(1)
+  #SFloatOne = NumRu::NArray.sfloat(1).fill!(1)
 end
 
 
@@ -332,10 +332,10 @@ module NumRu::NMath
 
 # 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?
+    x = NumRu::NArray.to_na(x) unless x.kind_of?(NumRu::NArray)
+    x = x.to_type(NumRu::NArray::DFLOAT) if x.integer?
+    y = NumRu::NArray.to_na(y) unless y.kind_of?(NumRu::NArray)
+    y = y.to_type(NumRu::NArray::DFLOAT) if y.integer?
     n = x.rank_total(*ranks)
     xm = x.accum(*ranks).div!(n)
     ym = y.accum(*ranks).div!(n)

data/lib/numru/nmatrix.rb

@@ -10,70 +10,70 @@ class NumRu::NMatrix < NumRu::NArray
 
   def +(other)
     case other
-    when NMatrix
-      return super(NArray.refer(other))
-    when NArray
-      unless other.instance_of?(NArray)
+    when NumRu::NMatrix
+      return super(NumRu::NArray.refer(other))
+    when NumRu::NArray
+      unless other.instance_of?(NumRu::NArray)
         return other.coerce_rev( self, :+ )
       end
     end
-    raise TypeError,"Illegal operation: NMatrix + %s" % other.class
+    raise TypeError,"Illegal operation: NumRu::NMatrix + %s" % other.class
   end
 
   def -(other)
     case other
-    when NMatrix
-      return super(NArray.refer(other))
-    when NArray
-      unless other.instance_of?(NArray)
+    when NumRu::NMatrix
+      return super(NumRu::NArray.refer(other))
+    when NumRu::NArray
+      unless other.instance_of?(NumRu::NArray)
         return other.coerce_rev( self, :- )
       end
     end
-    raise TypeError,"Illegal operation: NMatrix - %s" % other.class
+    raise TypeError,"Illegal operation: NumRu::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),
+    when NumRu::NMatrix
+      NumRu::NMatrix.mul_add( NumRu::NArray.refer(self).newdim!(0),other.newdim(2), 1 )
+      #NumRu::NMatrix.mul_add( NumRu::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) )
+    when NumRu::NVector
+      NumRu::NVector.mul_add( NumRu::NArray.refer(self), other.newdim(1), 0 )
+    when NumRu::NArray
+      if other.instance_of?(NumRu::NArray)
+	NumRu::NMatrix.mul( NumRu::NArray.refer(self), other.newdim(0,0) )
       else
 	other.coerce_rev( self, :* )
       end
     when Numeric
       super
-      #NMatrix.mul( NArray.refer(self), other )
+      #NumRu::NMatrix.mul( NumRu::NArray.refer(self), other )
     when Array
-      NMatrix.mul( self, NArray[*other].newdim!(0,0) )
+      NumRu::NMatrix.mul( self, NumRu::NArray[*other].newdim!(0,0) )
     else
-      raise TypeError,"Illegal operation: NMatrix * %s" % other.class
+      raise TypeError,"Illegal operation: NumRu::NMatrix * %s" % other.class
     end
   end
 
   def /(other)
     case other
-    when NMatrix
+    when NumRu::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) )
+    when NumRu::NVector
+      raise TypeError,"Illegal operation: NumRu::NMatrix / %s" % other.class
+    when NumRu::NArray
+      if other.instance_of?(NumRu::NArray)
+	NumRu::NMatrix.div( NumRu::NArray.refer(self), other.newdim(0,0) )
       else
 	other.coerce_rev( self, :/ )
       end
     when Numeric
-      NMatrix.div( NArray.refer(self), other )
+      NumRu::NMatrix.div( NumRu::NArray.refer(self), other )
     when Array
-      NMatrix.div( self, NArray[*other].newdim!(0,0) )
+      NumRu::NMatrix.div( self, NumRu::NArray[*other].newdim!(0,0) )
     else
-      raise TypeError,"Illegal operation: NMatrix / %s" % other.class
+      raise TypeError,"Illegal operation: NumRu::NMatrix / %s" % other.class
     end
   end
 
@@ -91,33 +91,33 @@ class NumRu::NMatrix < NumRu::NArray
       (2..n).each{ m *= self }
       m
     else
-      raise TypeError,"Illegal operation: NMatrix ** %s" % other.class
+      raise TypeError,"Illegal operation: NumRu::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 )
+	if other.instance_of?(NumRu::NArray)
+	  return NumRu::NMatrix.mul( other.newdim(0,0), self )
 	end
-	if other.instance_of?(NArrayScalar)
-	  return NMatrix.mul( other.newdim(0), self )
+	if other.instance_of?(NumRu::NArrayScalar)
+	  return NumRu::NMatrix.mul( other.newdim(0), self )
 	end
     when :/
-	if other.instance_of?(NArray)
-	  return NMatrix.mul( other.newdim(0,0), self.inverse )
+	if other.instance_of?(NumRu::NArray)
+	  return NumRu::NMatrix.mul( other.newdim(0,0), self.inverse )
 	end
-	if other.instance_of?(NArrayScalar)
-	  return NMatrix.mul( other.newdim(0), self.inverse )
+	if other.instance_of?(NumRu::NArrayScalar)
+	  return NumRu::NMatrix.mul( other.newdim(0), self.inverse )
 	end
     end
-    raise TypeError,"Illegal operation: %s %s NMatrix" %
+    raise TypeError,"Illegal operation: %s %s NumRu::NMatrix" %
       [other.class, id.id2name]
   end
 
   def inverse
-    self.lu.solve( NMatrix.new(self.typecode, *self.shape).fill!(0).unit )
+    self.lu.solve( NumRu::NMatrix.new(self.typecode, *self.shape).fill!(0).unit )
   end
 
   def transpose(*arg)
@@ -130,12 +130,12 @@ class NumRu::NMatrix < NumRu::NArray
 
   def diagonal!(val=1)
     shp = self.shape
-    idx = NArray.int(shp[0..1].min).indgen! * (shp[0]+1)
+    idx = NumRu::NArray.int(shp[0..1].min).indgen! * (shp[0]+1)
     ref = reshape(shp[0]*shp[1],true)
     if val.kind_of?(Numeric)
       ref[idx,true] = val
     else
-      val = NArray.to_na(val)
+      val = NumRu::NArray.to_na(val)
       raise ArgumentError, "must be 1-d array" if val.dim!=1
       ref[idx,true] = val.newdim!(-1)
     end
@@ -152,74 +152,74 @@ class NumRu::NMatrix < NumRu::NArray
   alias identity unit
   alias I unit
 
-end # class NMatrix
+end # class NumRu::NMatrix
 
 
 #
-# ------ NVector ------
+# ------ NumRu::NVector ------
 #
 class NumRu::NVector < NumRu::NArray
   CLASS_DIMENSION = 1
 
   def +(other)
     case other
-    when NVector
-      return super(NArray.refer(other))
-    when NArray
-      unless other.instance_of?(NArray)
+    when NumRu::NVector
+      return super(NumRu::NArray.refer(other))
+    when NumRu::NArray
+      unless other.instance_of?(NumRu::NArray)
         return other.coerce_rev( self, :+ )
       end
     end
-    raise TypeError,"Illegal operation: NVector + %s" % other.class
+    raise TypeError,"Illegal operation: NumRu::NVector + %s" % other.class
   end
 
   def -(other)
     case other
-    when NVector
-      return super(NArray.refer(other))
-    when NArray
-      unless other.instance_of?(NArray)
+    when NumRu::NVector
+      return super(NumRu::NArray.refer(other))
+    when NumRu::NArray
+      unless other.instance_of?(NumRu::NArray)
         return other.coerce_rev( self, :- )
       end
     end
-    raise TypeError,"Illegal operation: NVector - %s" % other.class
+    raise TypeError,"Illegal operation: NumRu::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) )
+    when NumRu::NMatrix
+      NumRu::NVector.mul_add( NumRu::NArray.refer(self).newdim!(0), other, 1 )
+    when NumRu::NVector
+      NumRu::NArray.mul_add( NumRu::NArray.refer(self), other, 0 ) # inner product
+    when NumRu::NArray
+      if other.instance_of?(NumRu::NArray)
+	NumRu::NVector.mul( NumRu::NArray.refer(self), other.newdim(0) )
       else
 	other.coerce_rev( self, :* )
       end
     when Numeric
-      NVector.mul( NArray.refer(self), other )
+      NumRu::NVector.mul( NumRu::NArray.refer(self), other )
     else
-      raise TypeError,"Illegal operation: NVector * %s" % other.class
+      raise TypeError,"Illegal operation: NumRu::NVector * %s" % other.class
     end
   end
 
   def /(other)
     case other
-    when NMatrix
+    when NumRu::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) )
+    when NumRu::NVector
+      raise TypeError,"Illegal operation: NumRu::NVector / %s" % other.class
+    when NumRu::NArray
+      if other.instance_of?(NumRu::NArray)
+	NumRu::NVector.div( NumRu::NArray.refer(self), other.newdim(0) )
       else
 	other.coerce_rev( self, :/ )
       end
     when Numeric
-      NVector.div( NArray.refer(self), other )
+      NumRu::NVector.div( NumRu::NArray.refer(self), other )
     else
-      raise TypeError,"Illegal operation: NVector / %s" % other.class
+      raise TypeError,"Illegal operation: NumRu::NVector / %s" % other.class
     end
   end
 
@@ -234,15 +234,15 @@ class NumRu::NVector < NumRu::NArray
   def coerce_rev(other,id)
     case id
     when :*
-	if other.instance_of?(NArray)
-	  return NVector.mul( other.newdim(0), self )
+	if other.instance_of?(NumRu::NArray)
+	  return NumRu::NVector.mul( other.newdim(0), self )
 	end
-	if other.instance_of?(NArrayScalar)
-	  return NVector.mul( other, self )
+	if other.instance_of?(NumRu::NArrayScalar)
+	  return NumRu::NVector.mul( other, self )
 	end
     end
-    raise TypeError,"Illegal operation: %s %s NVector" %
+    raise TypeError,"Illegal operation: %s %s NumRu::NVector" %
       [other.class, id.id2name]
   end
 
-end # class NVector
+end # class NumRu::NVector

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numru-narray
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Seiya Nishizawa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-12 00:00:00.000000000 Z
+date: 2016-02-15 00:00:00.000000000 Z
 dependencies: []
 description: NArray with big memory support
 email: seiya@gfd-dennou.org