numo-narray 0.9.0.1-x86-mingw32 → 0.9.0.3-x86-mingw32

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

@@ -0,0 +1,28 @@
+static VALUE
+<%=c_func%>(VALUE self)
+{
+    narray_t *na;
+    char *ptr;
+
+    GetNArray(self,na);
+
+    switch(NA_TYPE(na)) {
+    case NARRAY_DATA_T:
+        ptr = NA_DATA_PTR(na);
+        if (na->size > 0 && ptr == NULL) {
+            ptr = xmalloc(((na->size-1)/sizeof(BIT_DIGIT)+1)*sizeof(BIT_DIGIT)/8);
+            NA_DATA_PTR(na) = ptr;
+        }
+        break;
+    //case NARRAY_FILEMAP_T:
+    // to be implemented
+    //    ptr = ((narray_filemap_t*)na)->ptr;
+    //    break;
+    case NARRAY_VIEW_T:
+        rb_funcall(NA_VIEW_DATA(na), rb_intern("allocate"), 0);
+        break;
+    default:
+        rb_raise(rb_eRuntimeError,"invalid narray type");
+    }
+    return self;
+}

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

@@ -0,0 +1,53 @@
+/*
+  Array element referenece or slice view.
+  @overload [](dim0,...,dimL)
+  @param [Numeric,Range,etc] dim0,...,dimL  Multi-dimensional Index.
+  @return [Numeric,NArray::<%=class_name%>] Element object or NArray view.
+
+  --- Returns the element at +dim0+, +dim1+, ... are Numeric indices
+  for each dimension, or returns a NArray View as a sliced subarray if
+  +dim0+, +dim1+, ... includes other than Numeric index, e.g., Range
+  or Array or true.
+
+      a = Numo::DFloat.new(4,5).seq
+      => Numo::DFloat#shape=[4,5]
+      [[0, 1, 2, 3, 4],
+       [5, 6, 7, 8, 9],
+       [10, 11, 12, 13, 14],
+       [15, 16, 17, 18, 19]]
+
+      a[1,1]
+      => 6.0
+
+      a[1..3,1]
+      => Numo::DFloat#shape=[3]
+      [6, 11, 16]
+
+      a[1,[1,3,4]]
+      => Numo::DFloat#shape=[3]
+      [6, 8, 9]
+
+      a[true,2].fill(99)
+      a
+      => Numo::DFloat#shape=[4,5]
+      [[0, 1, 99, 3, 4],
+       [5, 6, 99, 8, 9],
+       [10, 11, 99, 13, 14],
+       [15, 16, 99, 18, 19]]
+ */
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE self)
+{
+    ssize_t pos;
+    char *ptr;
+    dtype x;
+
+    pos = na_get_scalar_position(self, argc, argv, 1);
+    if (pos == -1) {
+        return na_aref_main(argc, argv, self, 0);
+    } else {
+        ptr = na_get_pointer_for_read(self);
+        LOAD_BIT(ptr,pos,x);
+        return m_data_to_num(x);
+    }
+}

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

@@ -0,0 +1,63 @@
+/*
+  Array element(s) set.
+  @overload []=(dim0,..,dimL,val)
+  @param [Numeric,Range,etc] dim0,..,dimL  Multi-dimensional Index.
+  @param [Numeric,Numo::NArray,etc] val  Value(s) to be set to self.
+  @return [Numeric] returns val (last argument).
+
+  --- Replace element(s) at +dim0+, +dim1+, ... (index/range/array/true
+  for each dimention). Broadcasting mechanism is applied.
+
+      a = Numo::DFloat.new(3,4).seq
+      => Numo::DFloat#shape=[3,4]
+      [[0, 1, 2, 3],
+       [4, 5, 6, 7],
+       [8, 9, 10, 11]]
+
+      a[1,2]=99
+      a
+      => Numo::DFloat#shape=[3,4]
+      [[0, 1, 2, 3],
+       [4, 5, 99, 7],
+       [8, 9, 10, 11]]
+
+      a[1,[0,2]] = [101,102]
+      a
+      => Numo::DFloat#shape=[3,4]
+      [[0, 1, 2, 3],
+       [101, 5, 102, 7],
+       [8, 9, 10, 11]]
+
+      a[1,true]=99
+      a
+      => Numo::DFloat#shape=[3,4]
+      [[0, 1, 2, 3],
+       [99, 99, 99, 99],
+       [8, 9, 10, 11]]
+
+*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE self)
+{
+    ssize_t pos;
+    char *ptr;
+    VALUE a;
+    dtype x;
+
+    argc--;
+    if (argc==0) {
+        <%=c_func.sub(/_aset/,"_store")%>(self, argv[argc]);
+    } else {
+        pos = na_get_scalar_position(self, argc, argv, sizeof(dtype));
+        if (pos == -1) {
+            a = na_aref_main(argc, argv, self, 0);
+            <%=c_func.sub(/_aset/,"_store")%>(a, argv[argc]);
+        } else {
+            ptr = na_get_pointer_for_read_write(self);
+            x = m_num_to_data(argv[argc]);
+            STORE_BIT(ptr,pos,x);
+        }
+
+    }
+    return argv[argc];
+}

data/ext/numo/narray/gen/{tmpl/bit_binary.c → tmpl_bit/binary.c}

@@ -88,7 +88,7 @@ static VALUE
 {
     ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
     ndfunc_arg_out_t aout[1] = {{cT,0}};
-    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP, 2, 1, ain, aout };
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 2, 1, ain, aout };
 
     return na_ndloop(&ndf, 2, self, other);
 }

data/ext/numo/narray/gen/{tmpl → tmpl_bit}/bit_count.c

@@ -64,9 +64,11 @@ static void
 }
 
 /*
-  <%=method%>.
-  @overload <%=method%>
-  @return [Numo::Int64] the number of true bits.
+  Returns the number of bits.
+  If argument is supplied, return Int-array counted along the axes.
+  @overload <%=op_map%>([axis,..])
+  @param [Integer] axis  axes to be counted.
+  @return [Numo::Int64]
 */
 static VALUE
 <%=c_func%>(int argc, VALUE *argv, VALUE self)

data/ext/numo/narray/gen/tmpl_bit/bit_reduce.c

@@ -0,0 +1,128 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t     i;
+    BIT_DIGIT *a1, *a2;
+    size_t     p1,  p2;
+    ssize_t    s1,  s2;
+    size_t    *idx1, *idx2;
+    BIT_DIGIT  x=0, y=0;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    INIT_PTR_BIT_IDX(lp, 1, a2, p2, s2, idx2);
+    if (idx2) {
+        if (idx1) {
+            for (; i--;) {
+                LOAD_BIT(a2, p2+*idx2, y);
+                if (y == <%=init_bit%>) {
+                    LOAD_BIT(a1, p1+*idx1, x);
+                    if (x != <%=init_bit%>) {
+                        STORE_BIT(a2, p2+*idx2, x);
+                    }
+                }
+                idx1++;
+                idx2++;
+            }
+        } else {
+            for (; i--;) {
+                LOAD_BIT(a2, p2+*idx2, y);
+                if (y == <%=init_bit%>) {
+                    LOAD_BIT(a1, p1, x);
+                    if (x != <%=init_bit%>) {
+                        STORE_BIT(a2, p2+*idx2, x);
+                    }
+                }
+                p1 += s1;
+                idx2++;
+            }
+        }
+    } else if (s2) {
+        if (idx1) {
+            for (; i--;) {
+                LOAD_BIT(a2, p2, y);
+                if (y == <%=init_bit%>) {
+                    LOAD_BIT(a1, p1+*idx1, x);
+                    if (x != <%=init_bit%>) {
+                        STORE_BIT(a2, p2, x);
+                    }
+                }
+                idx1++;
+                p2 += s2;
+            }
+        } else {
+            for (; i--;) {
+                LOAD_BIT(a2, p2, y);
+                if (y == <%=init_bit%>) {
+                    LOAD_BIT(a1, p1, x);
+                    if (x != <%=init_bit%>) {
+                        STORE_BIT(a2, p2, x);
+                    }
+                }
+                p1 += s1;
+                p2 += s2;
+            }
+        }
+    } else {
+        LOAD_BIT(a2, p2, x);
+        if (x != <%=init_bit%>) {
+            return;
+        }
+        if (idx1) {
+            for (; i--;) {
+                LOAD_BIT(a1, p1+*idx1, y);
+                if (y != <%=init_bit%>) {
+                    STORE_BIT(a2, p2, y);
+                    return;
+                }
+                idx1++;
+            }
+        } else {
+            for (; i--;) {
+                LOAD_BIT(a1, p1, y);
+                if (y != <%=init_bit%>) {
+                    STORE_BIT(a2, p2, y);
+                    return;
+                }
+                p1 += s1;
+            }
+        }
+    }
+}
+
+/*
+<% case method
+   when /^any/ %>
+  Return true if any of bits is one (true).
+<% when /^all/ %>
+  Return true if all of bits are one (true).
+<% end %>
+  If argument is supplied, return Bit-array reduced along the axes.
+  @overload <%=op_map%>([axis,..])
+  @param [Integer] axis  axes to be reduced.
+  @return [Numo::Bit] .
+*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE v, reduce;
+    ndfunc_arg_in_t ain[3] = {{cT,0},{sym_reduce,0},{sym_init,0}};
+    ndfunc_arg_out_t aout[1] = {{numo_cBit,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 3,1, ain,aout};
+
+    reduce = na_reduce_dimension(argc, argv, 1, &self);
+    v = na_ndloop(&ndf, 3, self, reduce, INT2FIX(<%=init_bit%>));
+    if (argc > 0) {
+        return v;
+    }
+    v = numo_bit_extract(v);
+    switch (v) {
+    case INT2FIX(0):
+        return Qfalse;
+    case INT2FIX(1):
+        return Qtrue;
+    default:
+        rb_bug("unexpected result");
+        return v;
+    }
+}

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

@@ -0,0 +1,37 @@
+/*
+  Cast object to Numo::<%=class_name%>.
+  @overload [](elements)
+  @overload <%=method%>(array)
+  @param [Numeric,Array] elements
+  @param [Array] array
+  @return [Numo::<%=class_name%>]
+*/
+static VALUE
+<%=c_func%>(VALUE type, VALUE obj)
+{
+    VALUE v;
+    narray_t *na;
+    dtype x;
+
+    if (CLASS_OF(obj)==cT) {
+        return obj;
+    }
+    if (RTEST(rb_obj_is_kind_of(obj,rb_cNumeric))) {
+        x = m_num_to_data(obj);
+        return numo_<%=tp%>_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));
+        if (NA_SIZE(na) > 0) {
+            <%=find_tmpl("allocate").c_func%>(v);
+            <%=find_tmpl("store").c_func%>(v,obj);
+        }
+        return v;
+    }
+    rb_raise(nary_eCastError,"cannot cast to %s",rb_class2name(type));
+    return Qnil;
+}

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

@@ -0,0 +1,80 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t i, n;
+    size_t i1, n1;
+    VALUE  v1, *ptr;
+    BIT_DIGIT *a2;
+    size_t p2;
+    size_t s2, *idx2;
+    VALUE  x;
+    double y;
+    BIT_DIGIT z;
+    size_t len, c;
+    double beg, step;
+
+    v1 = lp->args[0].value;
+    ptr = &v1;
+    INIT_COUNTER(lp, n);
+    INIT_PTR_BIT_IDX(lp, 1, a2, p2, s2, idx2);
+
+    switch(TYPE(v1)) {
+    case T_ARRAY:
+        n1 = RARRAY_LEN(v1);
+        ptr = RARRAY_PTR(v1);
+        break;
+    case T_NIL:
+        n1 = 0;
+        break;
+    default:
+        n1 = 1;
+    }
+    if (idx2) {
+        <% ["STORE_BIT(a2, p2+*idx2, z); idx2++;",
+            "STORE_BIT(a2, p2, z); p2+=s2;"].each_with_index do |x,i| %>
+        for (i=i1=0; i1<n1 && i<n; i++,i1++) {
+            x = ptr[i1];
+            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, na_cStep)) {
+                nary_step_sequence(x,&len,&beg,&step);
+                for (c=0; c<len && i<n; c++,i++) {
+                    y = beg + step * c;
+                    z = m_from_double(y);
+                    <%= x %>
+                }
+            }
+            if (TYPE(x) != T_ARRAY) {
+                if (x == Qnil) x = INT2FIX(0);
+                z = m_num_to_data(x);
+                <%= x %>
+            }
+        }
+        z = m_zero;
+        for (; i<n; i++) {
+            <%= x %>
+        }
+        <% if i<1 %>
+    } else {
+        <% end
+        end %>
+    }
+}
+
+static VALUE
+<%=c_func%>(VALUE rary)
+{
+    volatile VALUE vnc, nary;
+    narray_t *na;
+    na_compose_t *nc;
+    ndfunc_arg_in_t ain[2] = {{rb_cArray,0},{Qnil,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2,0, ain,0};
+
+    vnc = na_ary_composition(rary);
+    Data_Get_Struct(vnc, na_compose_t, nc);
+    nary = rb_narray_new(cT, nc->ndim, nc->shape);
+    GetNArray(nary,na);
+    if (na->size > 0) {
+        <%=find_tmpl("allocate").c_func%>(nary);
+        na_ndloop_cast_rarray_to_narray(&ndf, rary, nary);
+    }
+    return nary;
+}

data/ext/numo/narray/gen/tmpl_bit/cast_numeric.c

@@ -0,0 +1,22 @@
+static VALUE
+ numo_<%=tp%>_new_dim0(dtype x)
+{
+    narray_t *na;
+    VALUE v;
+    dtype *ptr;
+
+    v = rb_narray_new(cT, 0, NULL);
+    GetNArray(v,na);
+    ptr = (dtype*)(char*)na_get_pointer_for_write(v);
+    *ptr = x;
+    na_release_lock(v);
+    return v;
+}
+
+static VALUE
+<%=c_func%>(VALUE x)
+{
+    dtype y;
+    y = m_num_to_data(x);
+    return numo_<%=tp%>_new_dim0(y);
+}

data/ext/numo/narray/gen/tmpl_bit/coerce_cast.c

@@ -0,0 +1,8 @@
+/*
+   @return [nil]
+*/
+static VALUE
+<%=c_func %>(VALUE value, VALUE type)
+{
+    return Qnil;
+}