numo-narray-alt 0.9.13 → 0.9.14

data/ext/numo/narray/src/mh/set_real.h

@@ -0,0 +1,60 @@
+#ifndef NUMO_NARRAY_MH_SET_REAL_H
+#define NUMO_NARRAY_MH_SET_REAL_H 1
+
+#define DEF_NARRAY_SET_REAL_METHOD_FUNC(tDType, tNAryClass, tRtDType, tRtNAryClass)            \
+  static void iter_##tDType##_set_real(na_loop_t* const lp) {                                  \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    size_t* idx1;                                                                              \
+    size_t* idx2;                                                                              \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    INIT_PTR_IDX(lp, 1, p2, s2, idx2);                                                         \
+    tDType x;                                                                                  \
+    tRtDType y;                                                                                \
+    if (idx1) {                                                                                \
+      if (idx2) {                                                                              \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          GET_DATA(p1 + *idx1, tDType, x);                                                     \
+          GET_DATA_INDEX(p2, idx2, tRtDType, y);                                               \
+          x = m_set_real(x, y);                                                                \
+          SET_DATA_INDEX(p1, idx1, tDType, x);                                                 \
+        }                                                                                      \
+      } else {                                                                                 \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          GET_DATA(p1 + *idx1, tDType, x);                                                     \
+          GET_DATA_STRIDE(p2, s2, tRtDType, y);                                                \
+          x = m_set_real(x, y);                                                                \
+          SET_DATA_INDEX(p1, idx1, tDType, x);                                                 \
+        }                                                                                      \
+      }                                                                                        \
+    } else {                                                                                   \
+      if (idx2) {                                                                              \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          GET_DATA(p1, tDType, x);                                                             \
+          GET_DATA_INDEX(p2, idx2, tRtDType, y);                                               \
+          x = m_set_real(x, y);                                                                \
+          SET_DATA_STRIDE(p1, s1, tDType, x);                                                  \
+        }                                                                                      \
+      } else {                                                                                 \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          GET_DATA(p1, tDType, x);                                                             \
+          GET_DATA_STRIDE(p2, s2, tRtDType, y);                                                \
+          x = m_set_real(x, y);                                                                \
+          SET_DATA_STRIDE(p1, s1, tDType, x);                                                  \
+        }                                                                                      \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_set_real(VALUE self, VALUE a1) {                                       \
+    ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { tRtNAryClass, 0 } };                        \
+    ndfunc_t ndf = { iter_##tDType##_set_real, FULL_LOOP, 2, 0, ain, 0 };                      \
+    na_ndloop(&ndf, 2, self, a1);                                                              \
+    return a1;                                                                                 \
+  }
+
+#endif /* NUMO_NARRAY_MH_SET_REAL_H */

data/ext/numo/narray/src/mh/signbit.h

@@ -0,0 +1,42 @@
+#ifndef NUMO_NARRAY_MH_SIGNBIT_H
+#define NUMO_NARRAY_MH_SIGNBIT_H 1
+
+#define DEF_NARRAY_SIGNBIT_METHOD_FUNC(tDType, tNAryClass)                                     \
+  static void iter_##tDType##_signbit(na_loop_t* const lp) {                                   \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    ssize_t s1;                                                                                \
+    size_t* idx1;                                                                              \
+    BIT_DIGIT* a2;                                                                             \
+    size_t p2;                                                                                 \
+    ssize_t s2;                                                                                \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    INIT_PTR_BIT(lp, 1, a2, p2, s2);                                                           \
+    BIT_DIGIT b;                                                                               \
+    tDType x;                                                                                  \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        GET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+        b = (m_signbit(x)) ? 1 : 0;                                                            \
+        STORE_BIT(a2, p2, b);                                                                  \
+        p2 += s2;                                                                              \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        GET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+        b = (m_signbit(x)) ? 1 : 0;                                                            \
+        STORE_BIT(a2, p2, b);                                                                  \
+        p2 += s2;                                                                              \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_signbit(VALUE self) {                                                  \
+    ndfunc_arg_in_t ain[1] = { { tNAryClass, 0 } };                                            \
+    ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };                                           \
+    ndfunc_t ndf = { iter_##tDType##_signbit, FULL_LOOP, 1, 1, ain, aout };                    \
+    return na_ndloop(&ndf, 1, self);                                                           \
+  }
+
+#endif /* NUMO_NARRAY_MH_SIGNBIT_H */

data/ext/numo/narray/src/t_bit.c

@@ -31,23 +31,31 @@ static ID id_to_a;
 VALUE cT;
 extern VALUE cRT;
 
+#include "mh/extract.h"
+#include "mh/aref.h"
 #include "mh/coerce_cast.h"
 #include "mh/to_a.h"
 #include "mh/fill.h"
 #include "mh/format.h"
 #include "mh/format_to_a.h"
 #include "mh/inspect.h"
+#include "mh/each.h"
+#include "mh/each_with_index.h"
 #include "mh/mean.h"
 #include "mh/var.h"
 #include "mh/stddev.h"
 #include "mh/rms.h"
 
+DEF_NARRAY_BIT_EXTRACT_METHOD_FUNC()
+DEF_NARRAY_BIT_AREF_METHOD_FUNC()
 DEF_NARRAY_COERCE_CAST_METHOD_FUNC(bit)
 DEF_NARRAY_BIT_TO_A_METHOD_FUNC()
 DEF_NARRAY_BIT_FILL_METHOD_FUNC()
 DEF_NARRAY_BIT_FORMAT_METHOD_FUNC()
 DEF_NARRAY_BIT_FORMAT_TO_A_METHOD_FUNC()
 DEF_NARRAY_BIT_INSPECT_METHOD_FUNC()
+DEF_NARRAY_BIT_EACH_METHOD_FUNC()
+DEF_NARRAY_BIT_EACH_WITH_INDEX_METHOD_FUNC()
 DEF_NARRAY_BIT_MEAN_METHOD_FUNC()
 DEF_NARRAY_BIT_VAR_METHOD_FUNC()
 DEF_NARRAY_BIT_STDDEV_METHOD_FUNC()
@@ -152,30 +160,6 @@ static VALUE bit_allocate(VALUE self) {
   return self;
 }
 
-/*
-  Extract an element only if self is a dimensionless NArray.
-  @overload extract
-    @return [Numeric,Numo::NArray]
-    --- Extract element value as Ruby Object if self is a dimensionless NArray,
-    otherwise returns self.
-*/
-
-static VALUE bit_extract(VALUE self) {
-  BIT_DIGIT *ptr, val;
-  size_t pos;
-  narray_t* na;
-  GetNArray(self, na);
-
-  if (na->ndim == 0) {
-    pos = na_get_offset(self);
-    ptr = (BIT_DIGIT*)na_get_pointer_for_read(self);
-    val = ((*((ptr) + (pos) / NB)) >> ((pos) % NB)) & 1u;
-    na_release_lock(self);
-    return INT2FIX(val);
-  }
-  return self;
-}
-
 static VALUE bit_new_dim0(dtype x) {
   VALUE v;
   dtype* ptr;
@@ -1268,53 +1252,6 @@ static VALUE bit_s_cast(VALUE type, VALUE obj) {
   return Qnil;
 }
 
-/*
-  Multi-dimensional element reference.
-  @overload [](dim0,...,dimL)
-    @param [Numeric,Range,Array,Numo::Int32,Numo::Int64,Numo::Bit,TrueClass,FalseClass,Symbol]
-    dim0,...,dimL  multi-dimensional indices.
-    @return [Numeric,Numo::Bit] an element or NArray view.
-  @see Numo::NArray#[]
-  @see #[]=
-
-  @example
-      a = Numo::Int32.new(3,4).seq
-      # => Numo::Int32#shape=[3,4]
-      # [[0, 1, 2, 3],
-      #  [4, 5, 6, 7],
-      #  [8, 9, 10, 11]]
-
-      b = (a%2).eq(0)
-      # => Numo::Bit#shape=[3,4]
-      # [[1, 0, 1, 0],
-      #  [1, 0, 1, 0],
-      #  [1, 0, 1, 0]]
-
-      b[true,(0..-1)%2]
-      # => Numo::Bit(view)#shape=[3,2]
-      # [[1, 1],
-      #  [1, 1],
-      #  [1, 1]]
-
-      b[1,1]
-      # => 0
- */
-static VALUE bit_aref(int argc, VALUE* argv, VALUE self) {
-  int nd;
-  size_t pos;
-  char* ptr;
-  dtype x;
-
-  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);
-    return m_data_to_num(x);
-  }
-}
-
 /*
   Multi-dimensional element assignment.
   @overload []=(dim0,...,dimL,val)
@@ -1365,111 +1302,6 @@ static VALUE bit_aset(int argc, VALUE* argv, VALUE self) {
   return argv[argc];
 }
 
-static void iter_bit_each(na_loop_t* const lp) {
-  size_t i;
-  BIT_DIGIT *a1, x = 0;
-  size_t p1;
-  ssize_t s1;
-  size_t* idx1;
-  VALUE y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
-  if (idx1) {
-    for (; i--;) {
-      LOAD_BIT(a1, p1 + *idx1, x);
-      idx1++;
-      y = m_data_to_num(x);
-      rb_yield(y);
-    }
-  } else {
-    for (; i--;) {
-      LOAD_BIT(a1, p1, x);
-      p1 += s1;
-      y = m_data_to_num(x);
-      rb_yield(y);
-    }
-  }
-}
-
-/*
-  Calls the given block once for each element in self,
-  passing that element as a parameter.
-  @overload each
-    @return [Numo::NArray] self
-    For a block {|x| ... }
-    @yield [x]  x is element of NArray.
-*/
-static VALUE bit_each(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
-  ndfunc_t ndf = { iter_bit_each, FULL_LOOP_NIP, 1, 0, ain, 0 };
-
-  na_ndloop(&ndf, 1, self);
-  return self;
-}
-
-static inline void yield_each_with_index(dtype x, size_t* c, VALUE* a, int nd, int md) {
-  int j;
-
-  a[0] = m_data_to_num(x);
-  for (j = 0; j <= nd; j++) {
-    a[j + 1] = SIZET2NUM(c[j]);
-  }
-  rb_yield(rb_ary_new4(md, a));
-}
-
-static void iter_bit_each_with_index(na_loop_t* const lp) {
-  size_t i;
-  BIT_DIGIT *a1, x = 0;
-  size_t p1;
-  ssize_t s1;
-  size_t* idx1;
-
-  VALUE* a;
-  size_t* c;
-  int nd, md;
-
-  c = (size_t*)(lp->opt_ptr);
-  nd = lp->ndim - 1;
-  md = lp->ndim + 1;
-  a = ALLOCA_N(VALUE, md);
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
-  c[nd] = 0;
-  if (idx1) {
-    for (; i--;) {
-      LOAD_BIT(a1, p1 + *idx1, x);
-      idx1++;
-      yield_each_with_index(x, c, a, nd, md);
-      c[nd]++;
-    }
-  } else {
-    for (; i--;) {
-      LOAD_BIT(a1, p1, x);
-      p1 += s1;
-      yield_each_with_index(x, c, a, nd, md);
-      c[nd]++;
-    }
-  }
-}
-
-/*
-  Invokes the given block once for each element of self,
-  passing that element and indices along each axis as parameters.
-  @overload each_with_index
-    @return [Numo::NArray] self
-    For a block {|x,i,j,...| ... }
-    @yield [x,i,j,...]  x is an element, i,j,... are multidimensional indices.
-*/
-static VALUE bit_each_with_index(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
-  ndfunc_t ndf = { iter_bit_each_with_index, FULL_LOOP_NIP, 1, 0, ain, 0 };
-
-  na_ndloop_with_index(&ndf, 1, self);
-  return self;
-}
-
 static void iter_bit_copy(na_loop_t* const lp) {
   size_t n;
   size_t p1, p3;
@@ -2993,11 +2825,50 @@ void Init_numo_bit(void) {
   rb_define_const(cT, "CONTIGUOUS_STRIDE", INT2FIX(1));
   rb_define_alloc_func(cT, bit_s_alloc_func);
   rb_define_method(cT, "allocate", bit_allocate, 0);
+  /**
+   * Extract an element only if self is a dimensionless NArray.
+   * @overload extract
+   *   @return [Numeric,Numo::NArray]
+   *   --- Extract element value as Ruby Object if self is a dimensionless NArray,
+   *   otherwise returns self.
+   */
   rb_define_method(cT, "extract", bit_extract, 0);
 
   rb_define_method(cT, "store", bit_store, 1);
 
   rb_define_singleton_method(cT, "cast", bit_s_cast, 1);
+  /**
+   * Multi-dimensional element reference.
+   * @overload [](dim0,...,dimL)
+   *   @param [Numeric,Range,Array,Numo::Int32,Numo::Int64,Numo::Bit,TrueClass,FalseClass,
+   *     Symbol]
+   *   dim0,...,dimL  multi-dimensional indices.
+   *   @return [Numeric,Numo::Bit] an element or NArray view.
+   * @see Numo::NArray#[]
+   * @see #[]=
+   *
+   * @example
+   *     a = Numo::Int32.new(3,4).seq
+   *     # => Numo::Int32#shape=[3,4]
+   *     # [[0, 1, 2, 3],
+   *     #  [4, 5, 6, 7],
+   *     #  [8, 9, 10, 11]]
+   *
+   *     b = (a%2).eq(0)
+   *     # => Numo::Bit#shape=[3,4]
+   *     # [[1, 0, 1, 0],
+   *     #  [1, 0, 1, 0],
+   *     #  [1, 0, 1, 0]]
+   *
+   *     b[true,(0..-1)%2]
+   *     # => Numo::Bit(view)#shape=[3,2]
+   *     # [[1, 1],
+   *     #  [1, 1],
+   *     #  [1, 1]]
+   *
+   *     b[1,1]
+   *     # => 0
+   */
   rb_define_method(cT, "[]", bit_aref, -1);
   rb_define_method(cT, "[]=", bit_aset, -1);
   /**
@@ -3039,7 +2910,23 @@ void Init_numo_bit(void) {
    *   @return [String]
    */
   rb_define_method(cT, "inspect", bit_inspect, 0);
+  /**
+   * Calls the given block once for each element in self,
+   * passing that element as a parameter.
+   * @overload each
+   *   @return [Numo::NArray] self
+   *   For a block {|x| ... }
+   *   @yield [x]  x is element of NArray.
+   */
   rb_define_method(cT, "each", bit_each, 0);
+  /**
+   * Invokes the given block once for each element of self,
+   * passing that element and indices along each axis as parameters.
+   * @overload each_with_index
+   *   @return [Numo::NArray] self
+   *   For a block {|x,i,j,...| ... }
+   *   @yield [x,i,j,...]  x is an element, i,j,... are multidimensional indices.
+   */
   rb_define_method(cT, "each_with_index", bit_each_with_index, 0);
   rb_define_method(cT, "copy", bit_copy, 0);
   rb_define_method(cT, "~", bit_not, 0);