numo-narray 0.9.0.3 → 0.9.0.4

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

@@ -11,7 +11,7 @@ if is_int && !is_object
   rand_type = "uint#{rand_bit}_t"
 %>
 
-#define HWID (sizeof(dtype)>>1)
+#define HWID (sizeof(dtype)*4)
 
 static int msb_pos(<%=rand_type%> a)
 {
@@ -109,7 +109,7 @@ static void
   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)
+  @param [Numeric] high  upper exclusive boundary of random numbers. (default=1 or 1+1i for complex types)
   @return [Numo::<%=class_name%>] self.
   @example
     Numo::DFloat.new(6).rand
@@ -131,14 +131,25 @@ static VALUE
     ndfunc_arg_in_t ain[1] = {{OVERWRITE,0}};
     ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 1,0, ain,0};
 
+    <% if is_int && !is_object %>
+    rb_scan_args(argc, args, "11", &v1, &v2);
+    if (v2==Qnil) {
+        g.low = m_zero;
+        g.max = high = m_num_to_data(v1);
+    <% else %>
     rb_scan_args(argc, args, "02", &v1, &v2);
     if (v2==Qnil) {
         g.low = m_zero;
         if (v1==Qnil) {
+            <% if is_complex %>
+            g.max = high = c_new(1,1);
+            <% else %>
             g.max = high = m_one;
+            <% end %>
         } else {
             g.max = high = m_num_to_data(v1);
         }
+    <% end %>
     } else {
         g.low = m_num_to_data(v1);
         high = m_num_to_data(v2);

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

@@ -1,3 +1,8 @@
+typedef struct {
+    dtype mu;
+    rtype sigma;
+} randn_opt_t;
+
 static void
 <%=c_iter%>(na_loop_t *const lp)
 {
@@ -5,42 +10,110 @@ static void
     char    *p1;
     ssize_t  s1;
     size_t  *idx1;
-    dtype    y;
-    dtype    a[2];
+    <% if is_complex %>
+    dtype   *a0;
+    <% else %>
+    dtype   *a0, *a1;
+    <% end %>
+    dtype    mu;
+    rtype    sigma;
+    randn_opt_t *g;
 
     INIT_COUNTER(lp, i);
     INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    g = (randn_opt_t*)(lp->opt_ptr);
+    mu = g->mu;
+    sigma = g->sigma;
+
     if (idx1) {
+        <% if is_complex %>
+        for (; i--;) {
+            a0 = (dtype*)(p1+*idx1);
+            m_rand_norm(mu,sigma,a0);
+            idx1 += 1;
+        }
+        <% else %>
         for (; i>1; i-=2) {
-            m_rand_norm(a);
-            *(dtype*)(p1+*idx1)     = a[0];
-            *(dtype*)(p1+*(idx1+1)) = a[1];
+            a0 = (dtype*)(p1+*idx1);
+            a1 = (dtype*)(p1+*(idx1+1));
+            m_rand_norm(mu,sigma,a0,a1);
             idx1 += 2;
         }
         if (i>0) {
-            m_rand_norm(a);
-            *(dtype*)(p1+*idx1) = a[0];
+            a0 = (dtype*)(p1+*idx1);
+            m_rand_norm(mu,sigma,a0,0);
         }
+        <% end %>
     } else {
+        <% if is_complex %>
+        for (; i--;) {
+            a0 = (dtype*)(p1);
+            m_rand_norm(mu,sigma,a0);
+            p1 += s1;
+        }
+        <% else %>
         for (; i>1; i-=2) {
-            m_rand_norm(a);
-            *(dtype*)(p1)    = a[0];
-            *(dtype*)(p1+s1) = a[1];
+            a0 = (dtype*)(p1);
+            a1 = (dtype*)(p1+s1);
+            m_rand_norm(mu,sigma,a0,a1);
             p1 += s1*2;
         }
         if (i>0) {
-            m_rand_norm(a);
-            *(dtype*)(p1) = a[0];
+            a0 = (dtype*)(p1);
+            m_rand_norm(mu,sigma,a0,0);
         }
+        <% end %>
     }
 }
 
+/*
+  Generates random numbers from the normal distribution on self narray
+  using Box-Muller Transformation.
+  @overload rand_norm([mu,[sigma]])
+  @param [Numeric] mu  mean of normal distribution. (default=0)
+  @param [Numeric] sigma  standard deviation of normal distribution. (default=1)
+  @return [Numo::<%=class_name%>] self.
+  @example
+    Numo::DFloat.new(5,5).rand_norm
+    => Numo::DFloat#shape=[5,5]
+       [[-0.581255, -0.168354, 0.586895, -0.595142, -0.802802],
+        [-0.326106, 0.282922, 1.68427, 0.918499, -0.0485384],
+        [-0.464453, -0.992194, 0.413794, -0.60717, -0.699695],
+        [-1.64168, 0.48676, -0.875871, -1.43275, 0.812172],
+        [-0.209975, -0.103612, -0.878617, -1.42495, 1.0968]]
+    Numo::DFloat.new(5,5).rand_norm(10,0.1)
+    => Numo::DFloat#shape=[5,5]
+       [[9.9019, 9.90339, 10.0826, 9.98384, 9.72861],
+        [9.81507, 10.0272, 9.91445, 10.0568, 9.88923],
+        [10.0234, 9.97874, 9.96011, 9.9006, 9.99964],
+        [10.0186, 9.94598, 9.92236, 9.99811, 9.97003],
+        [9.79266, 9.95044, 9.95212, 9.93692, 10.2027]]
+    Numo::DComplex.new(3,3).rand_norm(5+5i)
+    => Numo::DComplex#shape=[3,3]
+       [[5.84303+4.40052i, 4.00984+6.08982i, 5.10979+5.13215i],
+        [4.26477+3.99655i, 4.90052+5.00763i, 4.46607+2.3444i],
+        [4.5528+7.11003i, 5.62117+6.69094i, 5.05443+5.35133i]]
+*/
 static VALUE
-<%=c_func%>(VALUE self)
+<%=c_func%>(int argc, VALUE *args, VALUE self)
 {
+    int n;
+    randn_opt_t g;
+    VALUE v1=Qnil, v2=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};
 
-    na_ndloop(&ndf, 1, self);
-    return self
+    n = rb_scan_args(argc, args, "02", &v1, &v2);
+    if (n == 0) {
+        g.mu = m_zero;
+    } else {
+        g.mu = m_num_to_data(v1);
+    }
+    if (n == 2) {
+        g.sigma = NUM2DBL(v2);
+    } else {
+        g.sigma = 1;
+    }
+    na_ndloop3(&ndf, &g, 1, self);
+    return self;
 }

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

@@ -24,8 +24,12 @@ static VALUE
         }
     }
 
+    <% if is_object %>
+    numo_robject_store_numeric(self,obj);
+    <% else %>
     rb_raise(nary_eCastError, "unknown conversion from %s to %s",
              rb_class2name(CLASS_OF(obj)),
              rb_class2name(CLASS_OF(self)));
+    <% end %>
     return self;
 }

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

@@ -1,5 +1,102 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t i, n;
+    size_t i1, n1;
+    VALUE  v1, *ptr;
+    char   *p1;
+    size_t s1, *idx1;
+    VALUE  x;
+    double y;
+    dtype  z;
+    size_t len, c;
+    double beg, step;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    v1 = lp->args[1].value;
+    i = 0;
+
+    if (lp->args[1].ptr) {
+        if (v1 == Qtrue) {
+            iter_<%=tp%>_store_<%=tp%>(lp);
+            i = lp->args[1].shape[0];
+            if (idx1) {
+                idx1 += i;
+            } else {
+                p1 += s1 * i;
+            }
+        }
+        goto loop_end;
+    }
+
+    ptr = &v1;
+
+    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 (idx1) {
+        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);
+                    SET_DATA_INDEX(p1, idx1, dtype, z);
+                }
+            }
+            else if (TYPE(x) != T_ARRAY) {
+                z = m_num_to_data(x);
+                SET_DATA_INDEX(p1, idx1, dtype, z);
+            }
+        }
+    } else {
+        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);
+                    SET_DATA_STRIDE(p1, s1, dtype, z);
+                }
+            }
+            else if (TYPE(x) != T_ARRAY) {
+                z = m_num_to_data(x);
+                SET_DATA_STRIDE(p1, s1, dtype, z);
+            }
+        }
+    }
+
+ loop_end:
+    z = m_zero;
+    if (idx1) {
+        for (; i<n; i++) {
+            SET_DATA_INDEX(p1, idx1, dtype, z);
+        }
+    } else {
+        for (; i<n; i++) {
+            SET_DATA_STRIDE(p1, s1, dtype, z);
+        }
+    }
+}
+
 static VALUE
-<%=c_func%>(VALUE self, VALUE obj)
+<%=c_func%>(VALUE self, VALUE rary)
 {
-    return <%=find_tmpl("store").c_func%>(self,<%=find_tmpl("cast_array").c_func%>(obj));
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{rb_cArray,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2, 0, ain, 0};
+
+    na_ndloop_store_rarray(&ndf, self, rary);
+    return self;
 }

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

@@ -10,7 +10,7 @@ static VALUE
     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);
+            ptr = xmalloc(((na->size-1)/8/sizeof(BIT_DIGIT)+1)*sizeof(BIT_DIGIT));
             NA_DATA_PTR(na) = ptr;
         }
         break;

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

@@ -9,6 +9,7 @@
   +dim0+, +dim1+, ... includes other than Numeric index, e.g., Range
   or Array or true.
 
+  @example
       a = Numo::DFloat.new(4,5).seq
       => Numo::DFloat#shape=[4,5]
       [[0, 1, 2, 3, 4],
@@ -38,13 +39,14 @@
 static VALUE
 <%=c_func%>(int argc, VALUE *argv, VALUE self)
 {
-    ssize_t pos;
+    int nd;
+    size_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);
+    nd = na_get_result_dimension(self, argc, argv, 1, &pos);
+    if (nd) {
+        return na_aref_main(argc, argv, self, 0, nd);
     } else {
         ptr = na_get_pointer_for_read(self);
         LOAD_BIT(ptr,pos,x);

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

@@ -8,6 +8,7 @@
   --- Replace element(s) at +dim0+, +dim1+, ... (index/range/array/true
   for each dimention). Broadcasting mechanism is applied.
 
+  @example
       a = Numo::DFloat.new(3,4).seq
       => Numo::DFloat#shape=[3,4]
       [[0, 1, 2, 3],
@@ -39,7 +40,8 @@
 static VALUE
 <%=c_func%>(int argc, VALUE *argv, VALUE self)
 {
-    ssize_t pos;
+    int nd;
+    size_t pos;
     char *ptr;
     VALUE a;
     dtype x;
@@ -48,9 +50,9 @@ static VALUE
     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);
+        nd = na_get_result_dimension(self, argc, argv, 1, &pos);
+        if (nd) {
+            a = na_aref_main(argc, argv, self, 0, nd);
             <%=c_func.sub(/_aset/,"_store")%>(a, argv[argc]);
         } else {
             ptr = na_get_pointer_for_read_write(self);

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

@@ -1,80 +1,18 @@
-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;
+    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);
+    RB_GC_GUARD(vnc);
     GetNArray(nary,na);
     if (na->size > 0) {
         <%=find_tmpl("allocate").c_func%>(nary);
-        na_ndloop_cast_rarray_to_narray(&ndf, rary, nary);
+        <%=find_tmpl("store_array").c_func%>(nary, rary);
     }
     return nary;
 }