numo-narray 0.9.0.4 → 0.9.0.5

data/ext/numo/narray/gen/tmpl/accum_index.c

@@ -1,7 +1,8 @@
-<% [64,32].each do |i| %>
+<% (is_float ? ["","_nan"] : [""]).each do |j|
+   [64,32].each do |i| %>
 #define idx_t int<%=i%>_t
 static void
-<%=c_iter%>_index<%=i%>(na_loop_t *const lp)
+<%=c_iter%>_index<%=i%><%=j%>(na_loop_t *const lp)
 {
     size_t   n, idx;
     char    *d_ptr, *i_ptr, *o_ptr;
@@ -10,49 +11,70 @@ static void
     INIT_COUNTER(lp, n);
     INIT_PTR(lp, 0, d_ptr, d_step);
 
-    idx = f_<%=method%>(n,d_ptr,d_step);
+    idx = f_<%=name%><%=j%>(n,d_ptr,d_step);
 
     INIT_PTR(lp, 1, i_ptr, i_step);
     o_ptr = NDL_PTR(lp,2);
     *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
 }
 #undef idx_t
-<% end %>
+<% end;end %>
 
 /*
- *  call-seq:
- *     narray.<%=method%>() => Integer
- *     narray.<%=method%>(dim0,dim1,..) => Integer or Numo::Int32/64
- *
- *  Return an index of result.
- *
- *     Numo::NArray[3,4,1,2].min_index => 3
+  <%=name%>. Return an index of result.
+<% if is_float %>
+  @overload <%=name%>(axis:nil, nan:false)
+  @param [TrueClass] nan  If true, propagete NaN. If false, ignore NaN.
+<% else %>
+  @overload <%=name%>(axis:nil)
+<% end %>
+  @param [Numeric,Array,Range] axis  Affected dimensions.
+  @return [Integer,Numo::Int] returns result index of <%=name%>.
+  @example
+      Numo::NArray[3,4,1,2].min_index => 3
  */
 static VALUE
-<%=c_func%>(int argc, VALUE *argv, VALUE self)
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
+    int ignore_nan = 0;
     narray_t *na;
     VALUE idx, reduce;
     ndfunc_arg_in_t ain[3] = {{Qnil,0},{Qnil,0},{sym_reduce,0}};
     ndfunc_arg_out_t aout[1] = {{0,0,0}};
     ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 3,1, ain,aout};
 
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ignore_nan);
+
     GetNArray(self,na);
     if (na->ndim==0) {
         return INT2FIX(0);
     }
     if (na->size > (~(u_int32_t)0)) {
         aout[0].type = numo_cInt64;
-        idx = rb_narray_new(numo_cInt64, na->ndim, na->shape);
+        idx = nary_new(numo_cInt64, na->ndim, na->shape);
+<% if is_float %>
+        if (ignore_nan) {
+            ndf.func = <%=c_iter%>_index64_nan;
+        } else {
+            ndf.func = <%=c_iter%>_index64;
+        }
+<% else %>
         ndf.func = <%=c_iter%>_index64;
+<% end %>
     } else {
         aout[0].type = numo_cInt32;
-        idx = rb_narray_new(numo_cInt32, na->ndim, na->shape);
+        idx = nary_new(numo_cInt32, na->ndim, na->shape);
+<% if is_float %>
+        if (ignore_nan) {
+            ndf.func = <%=c_iter%>_index32_nan;
+        } else {
+            ndf.func = <%=c_iter%>_index32;
+        }
+<% else %>
         ndf.func = <%=c_iter%>_index32;
+<% end %>
     }
     rb_funcall(idx, rb_intern("seq"), 0);
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self);
-
     return na_ndloop(&ndf, 3, self, idx, reduce);
 }

data/ext/numo/narray/gen/tmpl/alloc_func.c

@@ -0,0 +1,107 @@
+static size_t
+<%=type_name%>_memsize(const void* ptr)
+{
+    size_t size = sizeof(narray_data_t);
+    const narray_data_t *na = (const narray_data_t*)ptr;
+
+    assert(na->base.type == NARRAY_DATA_T);
+
+    if (na->ptr != NULL) {
+  <% if is_bit %>
+        size += ((na->base.size-1)/8/sizeof(BIT_DIGIT)+1)*sizeof(BIT_DIGIT);
+  <% else %>
+        size += na->base.size * sizeof(dtype);
+  <% end %>
+    }
+    if (na->base.size > 0) {
+        if (na->base.shape != NULL && na->base.shape != &(na->base.size)) {
+            size += sizeof(size_t) * na->base.ndim;
+        }
+    }
+    return size;
+}
+
+static void
+<%=type_name%>_free(void* ptr)
+{
+    narray_data_t *na = (narray_data_t*)ptr;
+
+    assert(na->base.type == NARRAY_DATA_T);
+
+    if (na->ptr != NULL) {
+        xfree(na->ptr);
+        na->ptr = NULL;
+    }
+    if (na->base.size > 0) {
+        if (na->base.shape != NULL && na->base.shape != &(na->base.size)) {
+            xfree(na->base.shape);
+            na->base.shape = NULL;
+        }
+    }
+    xfree(na);
+}
+
+static narray_type_info_t <%=type_name%>_info = {
+  <% if is_bit %>
+    1,             // element_bits
+    0,             // element_bytes
+    1,             // element_stride (in bits)
+  <% else %>
+    0,             // element_bits
+    sizeof(dtype), // element_bytes
+    sizeof(dtype), // element_stride (in bytes)
+  <% end %>
+};
+
+<% if is_object %>
+static void
+<%=type_name%>_gc_mark(void *ptr)
+{
+    size_t n, i;
+    VALUE *a;
+    narray_data_t *na = ptr;
+
+    if (na->ptr) {
+        a = (VALUE*)(na->ptr);
+        n = na->base.size;
+        for (i=0; i<n; i++) {
+            rb_gc_mark(a[i]);
+        }
+    }
+}
+
+const rb_data_type_t <%=type_name%>_data_type = {
+    "<%=full_class_name%>",
+    {<%=type_name%>_gc_mark, <%=type_name%>_free, <%=type_name%>_memsize,},
+    &na_data_type,
+    &<%=type_name%>_info,
+    0, // flags
+};
+
+<% else %>
+
+const rb_data_type_t <%=type_name%>_data_type = {
+    "<%=full_class_name%>",
+    {0, <%=type_name%>_free, <%=type_name%>_memsize,},
+    &na_data_type,
+    &<%=type_name%>_info,
+    0, // flags
+};
+
+<% end %>
+
+VALUE
+<%=c_func(0)%>(VALUE klass)
+{
+    narray_data_t *na = ALLOC(narray_data_t);
+
+    na->base.ndim = 0;
+    na->base.type = NARRAY_DATA_T;
+    na->base.flag[0] = NA_FL0_INIT;
+    na->base.flag[1] = NA_FL1_INIT;
+    na->base.size = 0;
+    na->base.shape = NULL;
+    na->base.reduce = INT2FIX(0);
+    na->ptr = NULL;
+    return TypedData_Wrap_Struct(klass, &<%=type_name%>_data_type, (void*)na);
+}

data/ext/numo/narray/gen/tmpl/allocate.c

@@ -1,5 +1,5 @@
 static VALUE
-<%=c_func%>(VALUE self)
+<%=c_func(0)%>(VALUE self)
 {
     narray_t *na;
     char *ptr;

data/ext/numo/narray/gen/tmpl/aref.c

@@ -37,7 +37,7 @@
        [15, 16, 99, 18, 19]]
  */
 static VALUE
-<%=c_func%>(int argc, VALUE *argv, VALUE self)
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
     int nd;
     size_t pos;

data/ext/numo/narray/gen/tmpl/aset.c

@@ -38,12 +38,13 @@
 
 */
 static VALUE
-<%=c_func%>(int argc, VALUE *argv, VALUE self)
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
     int nd;
     size_t pos;
     char *ptr;
     VALUE a;
+    dtype x;
 
     argc--;
     if (argc==0) {
@@ -54,8 +55,9 @@ static VALUE
             a = na_aref_main(argc, argv, self, 0, nd);
             <%=c_func.sub(/_aset/,"_store")%>(a, argv[argc]);
         } else {
+            x = <%=type_name%>_extract_data(argv[argc]);
             ptr = na_get_pointer_for_read_write(self) + pos;
-            *(dtype*)ptr = m_num_to_data(argv[argc]);
+            *(dtype*)ptr = x;
         }
 
     }

data/ext/numo/narray/gen/tmpl/binary.c

@@ -12,13 +12,13 @@ static void
     for (i=n; i--;) {
         GET_DATA_STRIDE(p1,s1,dtype,x);
         GET_DATA_STRIDE(p2,s2,dtype,y);
-<% if is_int and %w[div mod divmod].include? method %>
+<% if is_int and %w[div mod divmod].include? name %>
         if (y==0) {
             lp->err_type = rb_eZeroDivError;
             return;
         }
 <% end %>
-        x = m_<%=method%>(x,y);
+        x = m_<%=name%>(x,y);
         SET_DATA_STRIDE(p3,s3,dtype,x);
     }
 }
@@ -34,13 +34,13 @@ static VALUE
 }
 
 /*
-  Binary <%=method%>.
+  Binary <%=name%>.
   @overload <%=op_map%> other
   @param [Numo::NArray,Numeric] other
   @return [Numo::NArray] self <%=op_map%> other
 */
 static VALUE
-<%=c_func%>(VALUE self, VALUE other)
+<%=c_func(1)%>(VALUE self, VALUE other)
 {
     <% if is_object %>
     return <%=c_func%>_self(self, other);

data/ext/numo/narray/gen/tmpl/binary2.c

@@ -13,13 +13,13 @@ static void
     for (i=n; i--;) {
         GET_DATA_STRIDE(p1,s1,dtype,x);
         GET_DATA_STRIDE(p2,s2,dtype,y);
-<% if is_int and %w[divmod].include? method %>
+<% if is_int and %w[divmod].include? name %>
         if (y==0) {
             lp->err_type = rb_eZeroDivError;
             return;
         }
 <% end %>
-        m_<%=method%>(x,y,a,b);
+        m_<%=name%>(x,y,a,b);
         SET_DATA_STRIDE(p3,s3,dtype,a);
         SET_DATA_STRIDE(p4,s4,dtype,b);
     }
@@ -36,13 +36,13 @@ static VALUE
 }
 
 /*
-  Binary <%=method%>.
+  Binary <%=name%>.
   @overload <%=op_map%> other
   @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] <%=method%> of self and other.
+  @return [Numo::NArray] <%=name%> of self and other.
 */
 static VALUE
-<%=c_func%>(VALUE self, VALUE other)
+<%=c_func(1)%>(VALUE self, VALUE other)
 {
     <% if is_object %>
     return <%=c_func%>_self(self, other);

data/ext/numo/narray/gen/tmpl/binary_s.c

@@ -12,20 +12,20 @@ static void
     for (; i--;) {
         GET_DATA_STRIDE(p1,s1,dtype,x);
         GET_DATA_STRIDE(p2,s2,dtype,y);
-        x = m_<%=method%>(x,y);
+        x = m_<%=name%>(x,y);
         SET_DATA_STRIDE(p3,s3,dtype,x);
     }
 }
 
 /*
-  Calculate <%=method%>(a1,a2).
-  @overload <%=method%>(a1,a2)
+  Calculate <%=name%>(a1,a2).
+  @overload <%=name%>(a1,a2)
   @param [Numo::NArray,Numeric] a1  first value
   @param [Numo::NArray,Numeric] a2  second value
-  @return [Numo::<%=class_name%>] <%=method%>(a1,a2).
+  @return [Numo::<%=class_name%>] <%=name%>(a1,a2).
 */
 static VALUE
-<%=c_func%>(VALUE mod, VALUE a1, VALUE a2)
+<%=c_func(2)%>(VALUE mod, VALUE a1, VALUE a2)
 {
     ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
     ndfunc_arg_out_t aout[1] = {{cT,0}};

data/ext/numo/narray/gen/tmpl/bincount.c

@@ -105,7 +105,7 @@ static VALUE
   Count the number of occurrences of each non-negative integer value.
   Only Integer-types has this method.
 
-  @overload <%=method%>([weight], minlength:nil)
+  @overload <%=name%>([weight], minlength:nil)
   @param [SFloat or DFloat or Array] weight (optional) Array of
     float values. Its size along last axis should be same as that of self.
   @param [Integer] minlength (keyword, optional) Minimum size along
@@ -134,7 +134,7 @@ static VALUE
 
 */
 static VALUE
-<%=c_func%>(int argc, VALUE *argv, VALUE self)
+<%=c_func(-1)%>(int argc, VALUE *argv, VALUE self)
 {
     VALUE weight=Qnil, kw=Qnil;
     VALUE opts[1] = {Qundef};
@@ -146,9 +146,9 @@ static VALUE
     rb_get_kwargs(kw, table, 0, 1, opts);
 
   <% if is_unsigned %>
-    v = numo_<%=type_name%>_max(0,0,self);
+    v = <%=type_name%>_max(0,0,self);
   <% else %>
-    v = numo_<%=type_name%>_minmax(0,0,self);
+    v = <%=type_name%>_minmax(0,0,self);
     if (m_num_to_data(RARRAY_AREF(v,0)) < 0) {
         rb_raise(rb_eArgError,"array items must be non-netagive");
     }

data/ext/numo/narray/gen/tmpl/cast.c

@@ -1,13 +1,17 @@
+<% children.each do |c|%>
+<%= c.result %>
+
+<% end %>
 /*
   Cast object to Numo::<%=class_name%>.
   @overload [](elements)
-  @overload <%=method%>(array)
+  @overload <%=name%>(array)
   @param [Numeric,Array] elements
   @param [Array] array
   @return [Numo::<%=class_name%>]
 */
 static VALUE
-<%=c_func%>(VALUE type, VALUE obj)
+<%=c_func(1)%>(VALUE type, VALUE obj)
 {
     VALUE v;
     narray_t *na;
@@ -18,22 +22,21 @@ static VALUE
     }
     if (RTEST(rb_obj_is_kind_of(obj,rb_cNumeric))) {
         x = m_num_to_data(obj);
-        return numo_<%=tp%>_new_dim0(x);
+        return <%=type_name%>_new_dim0(x);
     }
     if (RTEST(rb_obj_is_kind_of(obj,rb_cArray))) {
         return <%=find_tmpl("cast_array").c_func%>(obj);
     }
     if (IsNArray(obj)) {
         GetNArray(obj,na);
-        v = rb_narray_new(cT, NA_NDIM(na), NA_SHAPE(na));
+        v = nary_new(cT, NA_NDIM(na), NA_SHAPE(na));
         if (NA_SIZE(na) > 0) {
-            <%=find_tmpl("allocate").c_func%>(v);
             <%=find_tmpl("store").c_func%>(v,obj);
         }
         return v;
     }
     <% if is_object %>
-    return numo_robject_new_dim0(obj);
+    return robject_new_dim0(obj);
     <% else %>
     rb_raise(nary_eCastError,"cannot cast to %s",rb_class2name(type));
     return Qnil;

data/ext/numo/narray/gen/tmpl/cast_array.c

@@ -1,18 +1,13 @@
 static VALUE
-<%=c_func%>(VALUE rary)
+<%=c_func(:nodef)%>(VALUE rary)
 {
-    VALUE vnc, nary;
+    VALUE nary;
     narray_t *na;
-    na_compose_t *nc;
 
-    vnc = na_ary_composition(rary);
-    Data_Get_Struct(vnc, na_compose_t, nc);
-    nary = rb_narray_new(cT, nc->ndim, nc->shape);
-    RB_GC_GUARD(vnc);
+    nary = na_s_new_like(cT, rary);
     GetNArray(nary,na);
     if (na->size > 0) {
-        <%=find_tmpl("allocate").c_func%>(nary);
-        <%=find_tmpl("store_array").c_func%>(nary,rary);
+        <%=find_tmpl("store").find("array").c_func%>(nary,rary);
     }
     return nary;
 }

data/ext/numo/narray/gen/tmpl/class.c

@@ -0,0 +1,9 @@
+/*
+  class definition: <%= full_class_name %>
+*/
+
+VALUE <%=class_var%>;
+
+static VALUE <%= find('store').c_func %>(VALUE,VALUE);
+
+<%= method_code %>