numo-narray 0.9.0.1

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

@@ -0,0 +1,94 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  n;
+    size_t  p1, p2, p3;
+    ssize_t s1, s2, s3;
+    size_t *idx1, *idx2, *idx3;
+    int     o1, o2, l1, l2, r1, r2, len;
+    BIT_DIGIT *a1, *a2, *a3;
+    BIT_DIGIT  x, y;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    INIT_PTR_BIT_IDX(lp, 1, a2, p2, s2, idx2);
+    INIT_PTR_BIT_IDX(lp, 2, a3, p3, s3, idx3);
+    if (s1!=1 || s2!=1 || s3!=1 || idx1 || idx2 || idx3) {
+        for (; n--;) {
+            LOAD_BIT_STEP(a1, p1, s1, idx1, x);
+            LOAD_BIT_STEP(a2, p2, s2, idx2, y);
+            x = m_<%=method%>(x,y);
+            STORE_BIT_STEP(a3, p3, s3, idx3, x);
+        }
+    } else {
+        o1 =  p1 % NB;
+        o1 -= p3;
+        o2 =  p2 % NB;
+        o2 -= p3;
+        l1 =  NB+o1;
+        r1 =  NB-o1;
+        l2 =  NB+o2;
+        r2 =  NB-o2;
+        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++;
+            if (o2>=0) y = *a2>>o2;
+            else       y = *a2<<-o2;
+            if (p2+len>NB)  y |= *(a2+1)<<r2;
+            a2++;
+            x = m_<%=method%>(x,y);
+            *a3 = (x & (SLB(len)<<p3)) | (*a3 & ~(SLB(len)<<p3));
+            a3++;
+            n -= len;
+        }
+        if (o1==0 && o2==0) {
+            for (; n>=NB; n-=NB) {
+                x = *(a1++);
+                y = *(a2++);
+                x = m_<%=method%>(x,y);
+                *(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++;
+                y = *a2>>o2;
+                if (o2<0)  y |= *(a2-1)>>l2;
+                if (o2>0)  y |= *(a2+1)<<r2;
+                a2++;
+                x = m_<%=method%>(x,y);
+                *(a3++) = x;
+            }
+        }
+        if (n>0) {
+            x = *a1>>o1;
+            if (o1<0)  x |= *(a1-1)>>l1;
+            y = *a2>>o2;
+            if (o2<0)  y |= *(a2-1)>>l2;
+            x = m_<%=method%>(x,y);
+            *a3 = (x & SLB(n)) | (*a3 & BALL<<n);
+        }
+    }
+}
+
+/*
+  Binary <%=method%>.
+  @overload <%=op_map%> other
+  @param [Numo::NArray,Numeric] other
+  @return [Numo::NArray] <%=method%> of self and other.
+*/
+static VALUE
+<%=c_func%>(VALUE self, VALUE other)
+{
+    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 };
+
+    return na_ndloop(&ndf, 2, self, other);
+}

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

@@ -0,0 +1,82 @@
+#undef int_t
+#define int_t int64_t
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    BIT_DIGIT *a1;
+    size_t  p1;
+    char   *p2;
+    ssize_t s1, s2;
+    size_t *idx1;
+    BIT_DIGIT x=0;
+    int_t   y;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    INIT_PTR(lp, 1, p2, s2);
+    if (s2==0) {
+        GET_DATA(p2, int_t, y);
+        if (idx1) {
+            for (; i--;) {
+                LOAD_BIT(a1, p1+*idx1, x);
+                idx1++;
+                if (m_<%=method%>(x)) {
+                    y++;
+                }
+            }
+        } else {
+            for (; i--;) {
+                LOAD_BIT(a1, p1, x);
+                p1 += s1;
+                if (m_<%=method%>(x)) {
+                    y++;
+                }
+            }
+        }
+        *(int_t*)p2 = y;
+    } else {
+        if (idx1) {
+            for (; i--;) {
+                LOAD_BIT(a1, p1+*idx1, x);
+                idx1++;
+                if (m_<%=method%>(x)) {
+                    GET_DATA(p2, int_t, y);
+                    y++;
+                    SET_DATA(p2, int_t, y);
+                }
+                p2+=s2;
+            }
+        } else {
+            for (; i--;) {
+                LOAD_BIT(a1, p1, x);
+                p1+=s1;
+                if (m_<%=method%>(x)) {
+                    GET_DATA(p2, int_t, y);
+                    y++;
+                    SET_DATA(p2, int_t, y);
+                }
+                p2+=s2;
+            }
+        }
+    }
+}
+
+/*
+  <%=method%>.
+  @overload <%=method%>
+  @return [Numo::Int64] the number of true bits.
+*/
+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_cInt64,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(0));
+    return rb_funcall(v,rb_intern("extract"),0);
+}

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

@@ -0,0 +1,77 @@
+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;
+    BIT_DIGIT  y;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    INIT_PTR_BIT_IDX(lp, 1, a3, p3, s3, idx3);
+    if (s1!=1 || s3!=1 || idx1 || idx3) {
+        for (; n--;) {
+            LOAD_BIT_STEP(a1, p1, s1, idx1, x);
+            y = m_<%=method%>(x);
+            STORE_BIT_STEP(a3, p3, s3, idx3, y);
+        }
+    } 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++;
+            y = m_<%=method%>(x);
+            *a3 = (y & (SLB(len)<<p3)) | (*a3 & ~(SLB(len)<<p3));
+            a3++;
+            n -= len;
+        }
+        if (o1==0) {
+            for (; n>=NB; n-=NB) {
+                x = *(a1++);
+                y = m_<%=method%>(x);
+                *(a3++) = y;
+            }
+        } else {
+            for (; n>=NB; n-=NB) {
+                x = *a1>>o1;
+                if (o1<0)  x |= *(a1-1)>>l1;
+                if (o1>0)  x |= *(a1+1)<<r1;
+                a1++;
+                y = m_<%=method%>(x);
+                *(a3++) = y;
+            }
+        }
+        if (n>0) {
+            x = *a1>>o1;
+            if (o1<0)  x |= *(a1-1)>>l1;
+            y = m_<%=method%>(x);
+            *a3 = (y & SLB(n)) | (*a3 & BALL<<n);
+        }
+    }
+}
+
+/*
+  Unary <%=method%>.
+  @overload <%=method%>
+  @return [Numo::<%=class_name%>] <%=method%> of self.
+*/
+static VALUE
+<%=c_func%>(VALUE self)
+{
+    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 };
+
+    return na_ndloop(&ndf, 1, self);
+}

data/ext/numo/narray/gen/tmpl/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/cast_array.c

@@ -0,0 +1,79 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t i, n;
+    size_t i1, n1;
+    VALUE  v1, *ptr;
+    char   *p2;
+    size_t s2, *idx2;
+    VALUE  x;
+    double y;
+    dtype  z;
+    size_t len, c;
+    double beg, step;
+
+    v1 = lp->args[0].value;
+    ptr = &v1;
+    INIT_COUNTER(lp, n);
+    INIT_PTR_IDX(lp, 1, 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) {
+        <% ["SET_DATA_INDEX(p2, idx2, dtype, z)",
+            "SET_DATA_STRIDE(p2, s2, dtype, z)"].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 %>
+                }
+            }
+            else 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/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/coerce_cast.c

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

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

@@ -0,0 +1,51 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1, *p2;
+    BIT_DIGIT *a3;
+    size_t  p3;
+    ssize_t s1, s2, s3;
+    dtype   x, y;
+    BIT_DIGIT b;
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR_BIT(lp, 2, a3, p3, s3);
+    for (; i--;) {
+        GET_DATA_STRIDE(p1,s1,dtype,x);
+        GET_DATA_STRIDE(p2,s2,dtype,y);
+        b = (m_<%=method%>(x,y)) ? 1:0;
+        STORE_BIT(a3,p3,b);
+        p3+=s3;
+    }
+}
+
+static VALUE
+<%=c_func%>_self(VALUE self, VALUE other)
+{
+    ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
+    ndfunc_arg_out_t aout[1] = {{numo_cBit,0}};
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP, 2, 1, ain, aout };
+
+    return na_ndloop(&ndf, 2, self, other);
+}
+
+/*
+  Comparison <%=method%> other.
+  @overload <%=op_map%> other
+  @param [Numo::NArray,Numeric] other
+  @return [Numo::Bit] result of self <%=method%> other.
+*/
+static VALUE
+<%=c_func%>(VALUE self, VALUE other)
+{
+    VALUE klass, v;
+    klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
+    if (klass==cT) {
+        return <%=c_func%>_self(self, other);
+    } else {
+        v = rb_funcall(klass, id_cast, 1, self);
+        return rb_funcall(v, id_<%=method%>, 1, other);
+    }
+}