numo-narray 0.9.0.1 → 0.9.0.3

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

@@ -0,0 +1,14 @@
+VALUE
+numo_bit_none_p(int argc, VALUE *argv, VALUE self)
+{
+    VALUE v;
+
+    v = numo_bit_any_p(argc,argv,self);
+
+    if (v==Qtrue) {
+        return Qfalse;
+    } else if (v==Qfalse) {
+        return Qtrue;
+    }
+    return numo_bit_not(v);
+}

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

@@ -0,0 +1,32 @@
+/*
+  Store elements to Numo::<%=class_name%> from other.
+  @overload store(other)
+  @param [Object] other
+  @return [Numo::<%=class_name%>] self
+*/
+static VALUE
+<%=c_func%>(VALUE self, VALUE obj)
+{
+
+    VALUE r;
+
+    <% Store.definitions.each do |x| %>
+    if (<%=x.condition%>) {
+        <%=x.c_func%>(self,obj);
+        return self;
+    }
+    <% end %>
+
+    if (IsNArray(obj)) {
+        r = rb_funcall(obj, rb_intern("coerce_cast"), 1, cT);
+        if (CLASS_OF(r)==cT) {
+            <%=c_func%>(self,r);
+            return self;
+        }
+    }
+
+    rb_raise(nary_eCastError, "unknown conversion from %s to %s",
+             rb_class2name(CLASS_OF(obj)),
+             rb_class2name(CLASS_OF(self)));
+    return self;
+}

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

@@ -0,0 +1,5 @@
+static VALUE
+<%=c_func%>(VALUE self, VALUE obj)
+{
+    return <%=find_tmpl("store").c_func%>(self,<%=find_tmpl("cast_array").c_func%>(obj));
+}

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

@@ -0,0 +1,66 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  n;
+    size_t  p1, p3;
+    ssize_t s1, s3;
+    size_t *idx1, *idx3;
+    int     o1, l1, r1, len;
+    BIT_DIGIT *a1, *a3;
+    BIT_DIGIT  x;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR_BIT_IDX(lp, 0, a3, p3, s3, idx3);
+    INIT_PTR_BIT_IDX(lp, 1, a1, p1, s1, idx1);
+    if (s1!=1 || s3!=1 || idx1 || idx3) {
+        for (; n--;) {
+            LOAD_BIT_STEP(a1, p1, s1, idx1, x);
+            STORE_BIT_STEP(a3, p3, s3, idx3, x);
+        }
+    } else {
+        o1 =  p1 % NB;
+        o1 -= p3;
+        l1 =  NB+o1;
+        r1 =  NB-o1;
+        if (p3>0 || n<NB) {
+            len = NB - p3;
+            if ((int)n<len) len=n;
+            if (o1>=0) x = *a1>>o1;
+            else       x = *a1<<-o1;
+            if (p1+len>NB)  x |= *(a1+1)<<r1;
+            a1++;
+            *a3 = (x & (SLB(len)<<p3)) | (*a3 & ~(SLB(len)<<p3));
+            a3++;
+            n -= len;
+        }
+        if (o1==0) {
+            for (; n>=NB; n-=NB) {
+                x = *(a1++);
+                *(a3++) = x;
+            }
+        } else {
+            for (; n>=NB; n-=NB) {
+                x = *a1>>o1;
+                if (o1<0)  x |= *(a1-1)>>l1;
+                if (o1>0)  x |= *(a1+1)<<r1;
+                a1++;
+                *(a3++) = x;
+            }
+        }
+        if (n>0) {
+            x = *a1>>o1;
+            if (o1<0)  x |= *(a1-1)>>l1;
+            *a3 = (x & SLB(n)) | (*a3 & BALL<<n);
+        }
+    }
+}
+
+static VALUE
+<%=c_func%>(VALUE self, VALUE obj)
+{
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{Qnil,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2,0, ain,0};
+
+    na_ndloop(&ndf, 2, self, obj);
+    return self;
+}

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

@@ -0,0 +1,56 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    ssize_t  i, s1, s2;
+    size_t   p1;
+    char    *p2;
+    size_t  *idx1, *idx2;
+    <%=dtype%> x;
+    BIT_DIGIT *a1;
+    BIT_DIGIT  y;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    INIT_PTR_IDX(lp, 1, p2, s2, idx2);
+
+    if (idx2) {
+        if (idx1) {
+            for (; i--;) {
+                GET_DATA_INDEX(p2,idx2,<%=dtype%>,x);
+                y = <%=macro%>(x);
+                STORE_BIT(a1, p1+*idx1, y); idx1++;
+            }
+        } else {
+            for (; i--;) {
+                GET_DATA_INDEX(p2,idx2,<%=dtype%>,x);
+                y = <%=macro%>(x);
+                STORE_BIT(a1, p1, y); p1+=s1;
+            }
+        }
+    } else {
+        if (idx1) {
+            for (; i--;) {
+                GET_DATA_STRIDE(p2,s2,<%=dtype%>,x);
+                y = <%=macro%>(x);
+                STORE_BIT(a1, p1+*idx1, y); idx1++;
+            }
+        } else {
+            for (; i--;) {
+                GET_DATA_STRIDE(p2,s2,<%=dtype%>,x);
+                y = <%=macro%>(x);
+                STORE_BIT(a1, p1, y); p1+=s1;
+            }
+        }
+    }
+}
+
+
+static VALUE
+<%=c_func%>(VALUE self, VALUE obj)
+{
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{Qnil,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2,0, ain,0};
+
+    na_ndloop(&ndf, 2, self, obj);
+    return self;
+}

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

@@ -0,0 +1,22 @@
+static VALUE
+numo_<%=tp%>_new_dim0(dtype x)
+{
+    VALUE v;
+    dtype *ptr;
+
+    v = rb_narray_new(cT, 0, NULL);
+    ptr = (dtype*)(char*)na_get_pointer_for_write(v);
+    *ptr = x;
+    na_release_lock(v);
+    return v;
+}
+
+static VALUE
+<%=c_func%>(VALUE self, VALUE obj)
+{
+    dtype x;
+    x = m_num_to_data(obj);
+    obj = numo_<%=tp%>_new_dim0(x);
+    <%=find_tmpl("store").c_func%>(self,obj);
+    return self;
+}

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

@@ -0,0 +1,43 @@
+void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t     i;
+    BIT_DIGIT *a1;
+    size_t     p1;
+    ssize_t    s1;
+    size_t    *idx1;
+    BIT_DIGIT  x=0;
+    VALUE      a, y;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    a = rb_ary_new2(i);
+    rb_ary_push(lp->args[1].value, a);
+    if (idx1) {
+        for (; i--;) {
+            LOAD_BIT(a1,p1+*idx1,x); idx1++;
+            y = m_data_to_num(x);
+            rb_ary_push(a,y);
+        }
+    } else {
+        for (; i--;) {
+            LOAD_BIT(a1,p1,x); p1+=s1;
+            y = m_data_to_num(x);
+            rb_ary_push(a,y);
+        }
+    }
+}
+
+/*
+  Convert self to Array.
+  @overload <%=method%>
+  @return [Array]
+*/
+static VALUE
+<%=c_func%>(VALUE self)
+{
+    ndfunc_arg_in_t ain[3] = {{Qnil,0},{sym_loop_opt},{sym_option}};
+    ndfunc_arg_out_t aout[1] = {{rb_cArray,0}}; // dummy?
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 3,1, ain,aout};
+    return na_ndloop_cast_narray_to_rarray(&ndf, self, Qnil);
+}

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

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

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

@@ -0,0 +1,102 @@
+typedef struct {
+    size_t count;
+    char  *idx0;
+    char  *idx1;
+    size_t elmsz;
+} where_opt_t;
+
+#define STORE_INT(ptr, esz, x) memcpy(ptr,&(x),esz)
+
+static void
+iter_bit_where(na_loop_t *const lp)
+{
+    size_t  i;
+    BIT_DIGIT *a;
+    size_t  p;
+    ssize_t s;
+    size_t *idx;
+    BIT_DIGIT x=0;
+    char   *idx0, *idx1;
+    size_t  count;
+    size_t  e;
+    where_opt_t *g;
+
+    g = (where_opt_t*)(lp->opt_ptr);
+    count = g->count;
+    idx0  = g->idx0;
+    idx1  = g->idx1;
+    e     = g->elmsz;
+    INIT_COUNTER(lp, i);
+    INIT_PTR_BIT_IDX(lp, 0, a, p, s, idx);
+    if (idx) {
+        for (; i--;) {
+            LOAD_BIT(a, p+*idx, x);
+            idx++;
+            if (x==0) {
+                if (idx0) {
+                    STORE_INT(idx0,e,count);
+                    idx0 += e;
+                }
+            } else {
+                if (idx1) {
+                    STORE_INT(idx1,e,count);
+                    idx1 += e;
+                }
+            }
+            count++;
+        }
+    } else {
+        for (; i--;) {
+            LOAD_BIT(a, p, x);
+            p+=s;
+            if (x==0) {
+                if (idx0) {
+                    STORE_INT(idx0,e,count);
+                    idx0 += e;
+                }
+            } else {
+                if (idx1) {
+                    STORE_INT(idx1,e,count);
+                    idx1 += e;
+                }
+            }
+            count++;
+        }
+    }
+    g->count = count;
+    g->idx0  = idx0;
+    g->idx1  = idx1;
+}
+
+/*
+  Returns the array of index where the bit is one (true).
+  @overload <%=op_map%>
+  @return [Numo::Int32,Numo::Int64]
+*/
+static VALUE
+ numo_bit_where(VALUE self)
+{
+    volatile VALUE idx_1;
+    size_t size, n_1;
+    where_opt_t *g;
+
+    ndfunc_arg_in_t ain[1] = {{cT,0}};
+    ndfunc_t ndf = { iter_bit_where, FULL_LOOP, 1, 0, ain, 0 };
+
+    size = RNARRAY_SIZE(self);
+    n_1 = NUM2SIZET(numo_bit_count_true(0, NULL, self));
+    g = ALLOCA_N(where_opt_t,1);
+    g->count = 0;
+    if (size>4294967295ul) {
+        idx_1 = rb_narray_new(numo_cInt64, 1, &n_1);
+        g->elmsz = 8;
+    } else {
+        idx_1 = rb_narray_new(numo_cInt32, 1, &n_1);
+        g->elmsz = 4;
+    }
+    g->idx1 = na_get_pointer_for_write(idx_1);
+    g->idx0 = NULL;
+    na_ndloop3(&ndf, g, 1, self);
+    na_release_lock(idx_1);
+    return idx_1;
+}

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

@@ -0,0 +1,37 @@
+/*
+  Returns two index arrays.
+  The first array contains index where the bit is one (true).
+  The second array contains index where the bit is zero (false).
+  @overload <%=op_map%>
+  @return [Numo::Int32,Numo::Int64]*2
+*/
+static VALUE
+numo_bit_where2(VALUE self)
+{
+    VALUE idx_1, idx_0;
+    size_t size, n_1;
+    where_opt_t *g;
+
+    ndfunc_arg_in_t ain[1] = {{cT,0}};
+    ndfunc_t ndf = { iter_bit_where, FULL_LOOP, 1, 0, ain, 0 };
+
+    size = RNARRAY_SIZE(self);
+    n_1 = NUM2SIZET(numo_bit_count_true(0, NULL, self));
+    g = ALLOCA_N(where_opt_t,1);
+    g->count = 0;
+    if (size>4294967295ul) {
+        idx_1 = rb_narray_new(numo_cInt64, 1, &n_1);
+        idx_0 = rb_narray_new(numo_cInt64, 1, &n_1);
+        g->elmsz = 8;
+    } else {
+        idx_1 = rb_narray_new(numo_cInt32, 1, &n_1);
+        idx_0 = rb_narray_new(numo_cInt32, 1, &n_1);
+        g->elmsz = 4;
+    }
+    g->idx1 = na_get_pointer_for_write(idx_1);
+    g->idx0 = na_get_pointer_for_write(idx_0);
+    na_ndloop3(&ndf, g, 1, self);
+    na_release_lock(idx_0);
+    na_release_lock(idx_1);
+    return rb_assoc_new(idx_1,idx_0);
+}

data/ext/numo/narray/index.c

@@ -1,7 +1,7 @@
 /*
   index.c
   Numerical Array Extension for Ruby
-    (C) Copyright 1999-2011 by Masahiro TANAKA
+    (C) Copyright 1999-2016 by Masahiro TANAKA
 
   This program is free software.
   You can distribute/modify this program
@@ -152,7 +152,7 @@ na_parse_array(VALUE ary, int orig_dim, ssize_t size, na_index_arg_t *q)
     int n = RARRAY_LEN(ary);
     q->idx = ALLOC_N(size_t, n);
     for (k=0; k<n; k++) {
-        q->idx[k] = na_range_check(NUM2SSIZE(RARRAY_AREF(ary,k)), size, orig_dim);
+        q->idx[k] = na_range_check(NUM2SSIZET(RARRAY_AREF(ary,k)), size, orig_dim);
     }
     q->n    = n;
     q->beg  = 0;
@@ -207,7 +207,7 @@ na_parse_range(VALUE range, int orig_dim, ssize_t size, na_index_arg_t *q)
     if (beg < -size || beg >= size ||
         end < -size || end >= size) {
         rb_raise(rb_eRangeError,
-                 "beg=%ld,end=%ld is out of array size (%ld)",
+                 "beg=%"SZF"d,end=%"SZF"d is out of array size (%"SZF"d)",
                  beg, end, size);
     }
     n = end-beg+1;
@@ -232,11 +232,11 @@ na_index_parse_each(volatile VALUE a, ssize_t size, int i, na_index_arg_t *q)
         break;
 
     case T_BIGNUM:
-        na_index_set_scalar(q,i,size,NUM2SSIZE(a));
+        na_index_set_scalar(q,i,size,NUM2SSIZET(a));
         break;
 
     case T_FLOAT:
-        na_index_set_scalar(q,i,size,NUM2SSIZE(a));
+        na_index_set_scalar(q,i,size,NUM2SSIZET(a));
         break;
 
     case T_NIL:
@@ -257,6 +257,8 @@ na_index_parse_each(volatile VALUE a, ssize_t size, int i, na_index_arg_t *q)
         else if (a==sym_reduce || a==sym_sum || a==sym_plus) {
             na_index_set_step(q,i,size,0,1);
             q->reduce = 1;
+        } else {
+            rb_raise(rb_eIndexError, "invalid symbol for index");
         }
         break;
 
@@ -636,7 +638,7 @@ na_aref_main(int nidx, VALUE *idx, VALUE self, int keep_dim)
     na_index_arg_to_internal_order(nidx, idx, self);
 
     if (nidx==0) {
-        return na_copy(self);
+        return rb_funcall(self,rb_intern("copy"),0);
     }
     if (nidx==1) {
         if (CLASS_OF(*idx)==numo_cBit) {
@@ -744,7 +746,7 @@ na_get_scalar_position(VALUE self, int argc, VALUE *argv, ssize_t stride)
             break;
         case T_BIGNUM:
         case T_FLOAT:
-            idx[i] = NUM2SSIZE(argv[i]);
+            idx[i] = NUM2SSIZET(argv[i]);
             break;
         default:
             return -1;