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

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

@@ -52,7 +52,7 @@ static VALUE
             a = na_aref_main(argc, argv, self, 0);
             <%=c_func.sub(/_aset/,"_store")%>(a, argv[argc]);
         } else {
-            ptr = na_get_pointer_for_read(self) + pos;
+            ptr = na_get_pointer_for_read_write(self) + pos;
             *(dtype*)ptr = m_num_to_data(argv[argc]);
         }
 

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

@@ -5,7 +5,7 @@ yield_each_with_index(dtype x, size_t *c, VALUE *a, int nd, int md)
 
     a[0] = m_data_to_num(x);
     for (j=0; j<=nd; j++) {
-        a[j+1] = SIZE2NUM(c[j]);
+        a[j+1] = SIZET2NUM(c[j]);
     }
     rb_yield(rb_ary_new4(md,a));
 }

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

@@ -54,7 +54,7 @@ static VALUE
         rb_raise(rb_eArgError,"too many arguments (%d for 0..2)",argc);
     } else if (argc == 2) {
         data = m_num_to_data(argv[0]);
-        kofs = NUM2SSIZE(argv[1]);
+        kofs = NUM2SSIZET(argv[1]);
     } else if (argc == 1) {
         data = m_num_to_data(argv[0]);
         kofs = 0;
@@ -72,13 +72,13 @@ static VALUE
     // Diagonal offset from the main diagonal.
     if (kofs >= 0) {
         if ((size_t)(kofs) >= na->shape[nd-1]) {
-            rb_raise(rb_eArgError,"invalid diagonal offset(%ld) for "
-                     "last dimension size(%ld)",kofs,na->shape[nd-1]);
+            rb_raise(rb_eArgError,"invalid diagonal offset(%"SZF"d) for "
+                     "last dimension size(%"SZF"d)",kofs,na->shape[nd-1]);
         }
     } else {
         if ((size_t)(-kofs) >= na->shape[nd-2]) {
-            rb_raise(rb_eArgError,"invalid diagonal offset(%ld) for "
-                     "last-1 dimension size(%ld)",kofs,na->shape[nd-2]);
+            rb_raise(rb_eArgError,"invalid diagonal offset(%"SZF"d) for "
+                     "last-1 dimension size(%"SZF"d)",kofs,na->shape[nd-2]);
         }
     }
 

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

@@ -0,0 +1,82 @@
+typedef struct {
+    seq_data_t beg;
+    seq_data_t step;
+    seq_data_t base;
+    seq_count_t count;
+} logseq_opt_t;
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1;
+    ssize_t s1;
+    size_t *idx1;
+    dtype   x;
+    seq_data_t beg, step, base;
+    seq_count_t c;
+    logseq_opt_t *g;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    g = (logseq_opt_t*)(lp->opt_ptr);
+    beg  = g->beg;
+    step = g->step;
+    base = g->base;
+    c    = g->count;
+    if (idx1) {
+        for (; i--;) {
+            x = f_seq(beg,step,c++);
+            *(dtype*)(p1+*idx1) = m_pow(base,x);
+            idx1++;
+        }
+    } else {
+        for (; i--;) {
+            x = f_seq(beg,step,c++);
+            *(dtype*)(p1) = m_pow(base,x);
+            p1 += s1;
+        }
+    }
+    g->count = c;
+}
+
+/*
+  Set logarithmic sequence of numbers to self. The sequence is obtained from
+     base**(beg+i*step)
+  where i is 1-dimensional index.
+  Applicable classes: DFloat, SFloat, DComplex, SCopmplex.
+
+  @overload logseq(beg,step,[base])
+  @param [Numeric] beg  The begining of sequence.
+  @param [Numeric] step  The step of sequence.
+  @param [Numeric] base  The base of log space. (default=10)
+  @return [Numo::<%=class_name%>] self.
+
+  @example
+    Numo::DFloat.new(5).logseq(4,-1,2)
+    => Numo::DFloat#shape=[5]
+      [16, 8, 4, 2, 1]
+    Numo::DComplex.new(5).logseq(0,1i*Math::PI/3,Math::E)
+    => Numo::DComplex#shape=[5]
+      [1+7.26156e-310i, 0.5+0.866025i, -0.5+0.866025i, -1+1.22465e-16i, ...]
+*/
+static VALUE
+<%=c_func%>(int argc, VALUE *args, VALUE self)
+{
+    logseq_opt_t *g;
+    VALUE vbeg, vstep, vbase;
+    ndfunc_arg_in_t ain[1] = {{OVERWRITE,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 1,0, ain,0};
+
+    g = ALLOCA_N(logseq_opt_t,1);
+    rb_scan_args(argc, args, "21", &vbeg, &vstep, &vbase);
+    g->beg = m_num_to_data(vbeg);
+    g->step = m_num_to_data(vstep);
+    if (vbase==Qnil) {
+        g->base = m_from_real(10);
+    } else {
+        g->base = m_num_to_data(vbase);
+    }
+    na_ndloop3(&ndf, g, 1, self);
+    return self;
+}

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

@@ -6,7 +6,7 @@ yield_map_with_index(dtype x, size_t *c, VALUE *a, int nd, int md)
 
     a[0] = m_data_to_num(x);
     for (j=0; j<=nd; j++) {
-        a[j+1] = SIZE2NUM(c[j]);
+        a[j+1] = SIZET2NUM(c[j]);
     }
     y = rb_yield(rb_ary_new4(md,a));
     return m_num_to_data(y);

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

@@ -1,3 +1,76 @@
+<%
+if is_int && !is_object
+  if /Int64$/ =~ class_name
+    rand_bit = 64
+  else
+    rand_bit = 32
+  end
+  m_rand = "m_rand(max,shift)"
+  shift_def = "int shift;"
+  shift_set = "shift = #{rand_bit-1} - msb_pos(max);"
+  rand_type = "uint#{rand_bit}_t"
+%>
+
+#define HWID (sizeof(dtype)>>1)
+
+static int msb_pos(<%=rand_type%> a)
+{
+    int width = HWID;
+    int pos = 0;
+    <%=rand_type%> mask = (((dtype)1 << HWID)-1) << HWID;
+
+    if (a==0) {return -1;}
+
+    while (width) {
+        if (a & mask) {
+            pos += width;
+        } else {
+            mask >>= width;
+        }
+        width >>= 1;
+        mask &= mask << width;
+    }
+    return pos;
+}
+
+/* generates a random number on [0,max) */
+<% if rand_bit == 64 %>
+inline static dtype m_rand(uint64_t max, int shift)
+{
+    uint64_t x;
+    do {
+        x = gen_rand32();
+        x <<= 32;
+        x |= gen_rand32();
+        x >>= shift;
+    } while (x >= max);
+    return x;
+}
+<% else %>
+inline static dtype m_rand(uint32_t max, int shift)
+{
+    uint32_t x;
+    do {
+        x = gen_rand32();
+        x >>= shift;
+    } while (x >= max);
+    return x;
+}
+<% end %>
+<%
+else
+  m_rand = "m_rand(max)"
+  shift_def = ""
+  shift_set = ""
+  rand_type = "dtype"
+end
+%>
+
+typedef struct {
+    dtype low;
+    <%=rand_type%> max;
+} rand_opt_t;
+
 static void
 <%=c_iter%>(na_loop_t *const lp)
 {
@@ -6,28 +79,76 @@ static void
     ssize_t  s1;
     size_t  *idx1;
     dtype    x;
+    rand_opt_t *g;
+    dtype    low;
+    <%=rand_type%> max;
+    <%=shift_def%>
 
     INIT_COUNTER(lp, i);
     INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    g = (rand_opt_t*)(lp->opt_ptr);
+    low = g->low;
+    max = g->max;
+    <%=shift_set%>
+
     if (idx1) {
         for (; i--;) {
-            x = m_rand;
+            x = m_add(<%=m_rand%>,low);
             SET_DATA_INDEX(p1,idx1,dtype,x);
         }
     } else {
         for (; i--;) {
-            x = m_rand;
+            x = m_add(<%=m_rand%>,low);
             SET_DATA_STRIDE(p1,s1,dtype,x);
         }
     }
 }
 
+
+/*
+  Generate uniformly distributed random numbers on self narray.
+  @overload rand([[low],high])
+  @param [Numeric] low  lower inclusive boundary of random numbers. (default=0)
+  @param [Numeric] high  upper exclusive boundary of random numbers. (default=1)
+  @return [Numo::<%=class_name%>] self.
+  @example
+    Numo::DFloat.new(6).rand
+    => Numo::DFloat#shape=[6]
+       [0.0617545, 0.373067, 0.794815, 0.201042, 0.116041, 0.344032]
+    Numo::DComplex.new(6).rand(5+5i)
+    => Numo::DComplex#shape=[6]
+       [2.69974+3.68908i, 0.825443+0.254414i, 0.540323+0.34354i, 4.52061+2.39322i, ...]
+    Numo::Int32.new(6).rand(2,5)
+    => Numo::Int32#shape=[6]
+       [4, 3, 3, 2, 4, 2]
+*/
 static VALUE
-<%=c_func%>(VALUE self)
+<%=c_func%>(int argc, VALUE *args, VALUE self)
 {
+    rand_opt_t g;
+    VALUE v1=Qnil, v2=Qnil;
+    dtype high;
     ndfunc_arg_in_t ain[1] = {{OVERWRITE,0}};
-    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 1, 0, ain, 0 };
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 1,0, ain,0};
 
-    na_ndloop(&ndf, 1, self);
+    rb_scan_args(argc, args, "02", &v1, &v2);
+    if (v2==Qnil) {
+        g.low = m_zero;
+        if (v1==Qnil) {
+            g.max = high = m_one;
+        } else {
+            g.max = high = m_num_to_data(v1);
+        }
+    } else {
+        g.low = m_num_to_data(v1);
+        high = m_num_to_data(v2);
+        g.max = m_sub(high,g.low);
+    }
+    <% if is_int && !is_object %>
+    if (high <= g.low) {
+        rb_raise(rb_eArgError,"high must be larger than low");
+    }
+    <% end %>
+    na_ndloop3(&ndf, &g, 1, self);
     return self;
 }

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

@@ -1,3 +1,21 @@
+<% if is_int && !is_object %>
+typedef double seq_data_t;
+<% else %>
+typedef dtype seq_data_t;
+<% end %>
+
+<% if is_object %>
+typedef size_t seq_count_t;
+<% else %>
+typedef double seq_count_t;
+<% end %>
+
+typedef struct {
+    seq_data_t beg;
+    seq_data_t step;
+    seq_count_t count;
+} seq_opt_t;
+
 static void
 <%=c_iter%>(na_loop_t *const lp)
 {
@@ -5,8 +23,9 @@ static void
     char   *p1;
     ssize_t s1;
     size_t *idx1;
-    double  x, beg, step, c;
-    dtype   y;
+    dtype   x;
+    seq_data_t beg, step;
+    seq_count_t c;
     seq_opt_t *g;
 
     INIT_COUNTER(lp, i);
@@ -17,16 +36,14 @@ static void
     c    = g->count;
     if (idx1) {
         for (; i--;) {
-            x = beg + step * c++;
-            y = m_from_double(x);
-            *(dtype*)(p1+*idx1) = y;
+            x = f_seq(beg,step,c++);
+            *(dtype*)(p1+*idx1) = x;
             idx1++;
         }
     } else {
         for (; i--;) {
-            x = beg + step * c++;
-            y = m_from_double(x);
-            *(dtype*)(p1) = y;
+            x = f_seq(beg,step,c++);
+            *(dtype*)(p1) = x;
             p1 += s1;
         }
     }
@@ -34,11 +51,20 @@ static void
 }
 
 /*
-  Set Sequence of numbers to self NArray.
+  Set linear sequence of numbers to self. The sequence is obtained from
+     beg+i*step
+  where i is 1-dimensional index.
   @overload seq([beg,[step]])
   @param [Numeric] beg  begining of sequence. (default=0)
   @param [Numeric] step  step of sequence. (default=1)
   @return [Numo::<%=class_name%>] self.
+  @example
+    Numo::DFloat.new(6).seq(1,-0.2)
+    => Numo::DFloat#shape=[6]
+       [1, 0.8, 0.6, 0.4, 0.2, 0]
+    Numo::DComplex.new(6).seq(1,-0.2+0.2i)
+    => Numo::DComplex#shape=[6]
+       [1+0i, 0.8+0.2i, 0.6+0.4i, 0.4+0.6i, 0.2+0.8i, 0+1i]
 */
 static VALUE
 <%=c_func%>(int argc, VALUE *args, VALUE self)
@@ -46,15 +72,20 @@ static VALUE
     seq_opt_t *g;
     VALUE vbeg=Qnil, vstep=Qnil;
     ndfunc_arg_in_t ain[1] = {{OVERWRITE,0}};
-    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 1, 0, ain, 0 };
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 1,0, ain,0};
 
     g = ALLOCA_N(seq_opt_t,1);
-    g->beg = 0;
-    g->step = 1;
+    g->beg = m_zero;
+    g->step = m_one;
     g->count = 0;
     rb_scan_args(argc, args, "02", &vbeg, &vstep);
+<% if is_int && !is_object %>
     if (vbeg!=Qnil) {g->beg = NUM2DBL(vbeg);}
     if (vstep!=Qnil) {g->step = NUM2DBL(vstep);}
+<% else %>
+    if (vbeg!=Qnil) {g->beg = m_num_to_data(vbeg);}
+    if (vstep!=Qnil) {g->step = m_num_to_data(vstep);}
+<% end %>
 
     na_ndloop3(&ndf, g, 1, self);
     return self;

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

@@ -0,0 +1,55 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t     i;
+    char      *p1;
+    size_t     p2;
+    ssize_t    s1, s2;
+    size_t    *idx1, *idx2;
+    BIT_DIGIT *a2, x;
+    dtype      y;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    INIT_PTR_BIT_IDX(lp, 1, a2, p2, s2, idx2);
+    if (idx2) {
+        if (idx1) {
+            for (; i--;) {
+                LOAD_BIT(a2, p2+*idx2, x); idx2++;
+                y = m_from_real(x);
+                SET_DATA_INDEX(p1,idx1,dtype,y);
+            }
+        } else {
+            for (; i--;) {
+                LOAD_BIT(a2, p2+*idx2, x); idx2++;
+                y = m_from_real(x);
+                SET_DATA_STRIDE(p1,s1,dtype,y);
+            }
+        }
+    } else {
+        if (idx1) {
+            for (; i--;) {
+                LOAD_BIT(a2, p2, x); p2 += s2;
+                y = m_from_real(x);
+                SET_DATA_INDEX(p1,idx1,dtype,y);
+            }
+        } else {
+            for (; i--;) {
+                LOAD_BIT(a2, p2, x); p2 += s2;
+                y = m_from_real(x);
+                SET_DATA_STRIDE(p1,s1,dtype,y);
+            }
+        }
+    }
+}
+
+
+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;
+}