numo-narray-alt 0.9.13 → 0.9.14

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

@@ -43,12 +43,19 @@ 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/map.h"
+#include "mh/each_with_index.h"
+#include "mh/map_with_index.h"
+#include "mh/abs.h"
 #include "mh/op/add.h"
 #include "mh/op/sub.h"
 #include "mh/op/mul.h"
@@ -92,6 +99,7 @@ extern VALUE cRT;
 #include "mh/seq.h"
 #include "mh/eye.h"
 #include "mh/rand.h"
+#include "mh/poly.h"
 #include "mh/mean.h"
 #include "mh/var.h"
 #include "mh/stddev.h"
@@ -99,12 +107,19 @@ extern VALUE cRT;
 
 typedef u_int16_t uint16; // Type aliases for shorter notation
                           // following the codebase naming convention.
+DEF_NARRAY_EXTRACT_METHOD_FUNC(uint16)
+DEF_NARRAY_AREF_METHOD_FUNC(uint16)
 DEF_NARRAY_COERCE_CAST_METHOD_FUNC(uint16)
 DEF_NARRAY_TO_A_METHOD_FUNC(uint16)
 DEF_NARRAY_FILL_METHOD_FUNC(uint16)
 DEF_NARRAY_FORMAT_METHOD_FUNC(uint16)
 DEF_NARRAY_FORMAT_TO_A_METHOD_FUNC(uint16)
 DEF_NARRAY_INSPECT_METHOD_FUNC(uint16)
+DEF_NARRAY_EACH_METHOD_FUNC(uint16)
+DEF_NARRAY_MAP_METHOD_FUNC(uint16, numo_cUInt16)
+DEF_NARRAY_EACH_WITH_INDEX_METHOD_FUNC(uint16)
+DEF_NARRAY_MAP_WITH_INDEX_METHOD_FUNC(uint16, numo_cUInt16)
+DEF_NARRAY_ABS_METHOD_FUNC(uint16, numo_cUInt16, uint16, numo_cUInt16)
 DEF_NARRAY_ADD_METHOD_FUNC(uint16, numo_cUInt16)
 DEF_NARRAY_SUB_METHOD_FUNC(uint16, numo_cUInt16)
 DEF_NARRAY_MUL_METHOD_FUNC(uint16, numo_cUInt16)
@@ -148,6 +163,7 @@ DEF_NARRAY_INT_MULSUM_METHOD_FUNC(uint16, numo_cUInt16)
 DEF_NARRAY_INT_SEQ_METHOD_FUNC(uint16)
 DEF_NARRAY_EYE_METHOD_FUNC(uint16)
 DEF_NARRAY_INT_RAND_METHOD_FUNC(uint16)
+DEF_NARRAY_POLY_METHOD_FUNC(uint16, numo_cUInt16)
 DEF_NARRAY_INT_MEAN_METHOD_FUNC(uint16, numo_cUInt16)
 DEF_NARRAY_INT_VAR_METHOD_FUNC(uint16, numo_cUInt16)
 DEF_NARRAY_INT_STDDEV_METHOD_FUNC(uint16, numo_cUInt16)
@@ -256,28 +272,6 @@ static VALUE uint16_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 uint16_extract(VALUE self) {
-  volatile VALUE v;
-  char* ptr;
-  narray_t* na;
-  GetNArray(self, na);
-
-  if (na->ndim == 0) {
-    ptr = na_get_pointer_for_read(self) + na_get_offset(self);
-    v = m_extract(ptr);
-    na_release_lock(self);
-    return v;
-  }
-  return self;
-}
-
 static VALUE uint16_new_dim0(dtype x) {
   VALUE v;
   dtype* ptr;
@@ -1255,29 +1249,6 @@ static VALUE uint16_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::UInt16] an element or NArray view.
-  @see Numo::NArray#[]
-  @see #[]=
- */
-static VALUE uint16_aref(int argc, VALUE* argv, VALUE self) {
-  int nd;
-  size_t pos;
-  char* ptr;
-
-  nd = na_get_result_dimension(self, argc, argv, sizeof(dtype), &pos);
-  if (nd) {
-    return na_aref_main(argc, argv, self, 0, nd);
-  } else {
-    ptr = na_get_pointer_for_read(self) + pos;
-    return m_extract(ptr);
-  }
-}
-
 /*
   Multi-dimensional element assignment.
   @overload []=(dim0,...,dimL,val)
@@ -1312,378 +1283,6 @@ static VALUE uint16_aset(int argc, VALUE* argv, VALUE self) {
   return argv[argc];
 }
 
-static void iter_uint16_each(na_loop_t* const lp) {
-  size_t i, s1;
-  char* p1;
-  size_t* idx1;
-  dtype x;
-  VALUE y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  if (idx1) {
-    for (; i--;) {
-      GET_DATA_INDEX(p1, idx1, dtype, x);
-      y = m_data_to_num(x);
-      rb_yield(y);
-    }
-  } else {
-    for (; i--;) {
-      GET_DATA_STRIDE(p1, s1, dtype, x);
-      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| ... }`,
-    @yieldparam [Numeric] x  an element of NArray.
-  @see #each_with_index
-  @see #map
-*/
-static VALUE uint16_each(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint16_each, FULL_LOOP_NIP, 1, 0, ain, 0 };
-
-  na_ndloop(&ndf, 1, self);
-  return self;
-}
-
-static void iter_uint16_map(na_loop_t* const lp) {
-  size_t i, n;
-  char *p1, *p2;
-  ssize_t s1, s2;
-  size_t *idx1, *idx2;
-  dtype x;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-
-  if (idx1) {
-    if (idx2) {
-      for (i = 0; i < n; i++) {
-        GET_DATA_INDEX(p1, idx1, dtype, x);
-        x = m_map(x);
-        SET_DATA_INDEX(p2, idx2, dtype, x);
-      }
-    } else {
-      for (i = 0; i < n; i++) {
-        GET_DATA_INDEX(p1, idx1, dtype, x);
-        x = m_map(x);
-        SET_DATA_STRIDE(p2, s2, dtype, x);
-      }
-    }
-  } else {
-    if (idx2) {
-      for (i = 0; i < n; i++) {
-        GET_DATA_STRIDE(p1, s1, dtype, x);
-        x = m_map(x);
-        SET_DATA_INDEX(p2, idx2, dtype, x);
-      }
-    } else {
-      //
-      if (is_aligned(p1, sizeof(dtype)) && is_aligned(p2, sizeof(dtype))) {
-        if (s1 == sizeof(dtype) && s2 == sizeof(dtype)) {
-          for (i = 0; i < n; i++) {
-            ((dtype*)p2)[i] = m_map(((dtype*)p1)[i]);
-          }
-          return;
-        }
-        if (is_aligned_step(s1, sizeof(dtype)) && is_aligned_step(s2, sizeof(dtype))) {
-          //
-          for (i = 0; i < n; i++) {
-            *(dtype*)p2 = m_map(*(dtype*)p1);
-            p1 += s1;
-            p2 += s2;
-          }
-          return;
-          //
-        }
-      }
-      for (i = 0; i < n; i++) {
-        GET_DATA_STRIDE(p1, s1, dtype, x);
-        x = m_map(x);
-        SET_DATA_STRIDE(p2, s2, dtype, x);
-      }
-      //
-    }
-  }
-}
-
-/*
-  Unary map.
-  @overload map
-    @return [Numo::UInt16] map of self.
-*/
-static VALUE uint16_map(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf = { iter_uint16_map, FULL_LOOP, 1, 1, ain, aout };
-
-  return na_ndloop(&ndf, 1, 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_uint16_each_with_index(na_loop_t* const lp) {
-  size_t i, s1;
-  char* p1;
-  size_t* idx1;
-  dtype x;
-  VALUE* a;
-  size_t* c;
-  int nd, md;
-
-  c = (size_t*)(lp->opt_ptr);
-  nd = lp->ndim;
-  if (nd > 0) {
-    nd--;
-  }
-  md = nd + 2;
-  a = ALLOCA_N(VALUE, md);
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  c[nd] = 0;
-  if (idx1) {
-    for (; i--;) {
-      GET_DATA_INDEX(p1, idx1, dtype, x);
-      yield_each_with_index(x, c, a, nd, md);
-      c[nd]++;
-    }
-  } else {
-    for (; i--;) {
-      GET_DATA_STRIDE(p1, s1, dtype, x);
-      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
-    For a block `{|x,i,j,...| ... }`,
-    @yieldparam [Numeric] x  an element
-    @yieldparam [Integer] i,j,...  multitimensional indices
-    @return [Numo::NArray] self
-  @see #each
-  @see #map_with_index
-*/
-static VALUE uint16_each_with_index(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint16_each_with_index, FULL_LOOP_NIP, 1, 0, ain, 0 };
-
-  na_ndloop_with_index(&ndf, 1, self);
-  return self;
-}
-
-static inline dtype yield_map_with_index(dtype x, size_t* c, VALUE* a, int nd, int md) {
-  int j;
-  VALUE y;
-
-  a[0] = m_data_to_num(x);
-  for (j = 0; j <= nd; j++) {
-    a[j + 1] = SIZET2NUM(c[j]);
-  }
-  y = rb_yield(rb_ary_new4(md, a));
-  return m_num_to_data(y);
-}
-
-static void iter_uint16_map_with_index(na_loop_t* const lp) {
-  size_t i;
-  char *p1, *p2;
-  ssize_t s1, s2;
-  size_t *idx1, *idx2;
-  dtype x;
-  VALUE* a;
-  size_t* c;
-  int nd, md;
-
-  c = (size_t*)(lp->opt_ptr);
-  nd = lp->ndim;
-  if (nd > 0) {
-    nd--;
-  }
-  md = nd + 2;
-  a = ALLOCA_N(VALUE, md);
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-
-  c[nd] = 0;
-  if (idx1) {
-    if (idx2) {
-      for (; i--;) {
-        GET_DATA_INDEX(p1, idx1, dtype, x);
-        x = yield_map_with_index(x, c, a, nd, md);
-        SET_DATA_INDEX(p2, idx2, dtype, x);
-        c[nd]++;
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p1, idx1, dtype, x);
-        x = yield_map_with_index(x, c, a, nd, md);
-        SET_DATA_STRIDE(p2, s2, dtype, x);
-        c[nd]++;
-      }
-    }
-  } else {
-    if (idx2) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p1, s1, dtype, x);
-        x = yield_map_with_index(x, c, a, nd, md);
-        SET_DATA_INDEX(p2, idx2, dtype, x);
-        c[nd]++;
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p1, s1, dtype, x);
-        x = yield_map_with_index(x, c, a, nd, md);
-        SET_DATA_STRIDE(p2, s2, dtype, x);
-        c[nd]++;
-      }
-    }
-  }
-}
-
-/*
-  Invokes the given block once for each element of self,
-  passing that element and indices along each axis as parameters.
-  Creates a new NArray containing the values returned by the block.
-  Inplace option is allowed, i.e., `nary.inplace.map` overwrites `nary`.
-  @overload map_with_index
-    For a block `{|x,i,j,...| ... }`,
-    @yieldparam [Numeric] x  an element
-    @yieldparam [Integer] i,j,...  multitimensional indices
-    @return [Numo::NArray] mapped array
-  @see #map
-  @see #each_with_index
-*/
-static VALUE uint16_map_with_index(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf = { iter_uint16_map_with_index, FULL_LOOP, 1, 1, ain, aout };
-
-  return na_ndloop_with_index(&ndf, 1, self);
-}
-
-static void iter_uint16_abs(na_loop_t* const lp) {
-  size_t i;
-  char *p1, *p2;
-  ssize_t s1, s2;
-  size_t *idx1, *idx2;
-  dtype x;
-  rtype y;
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-  if (idx1) {
-    if (idx2) {
-      for (; i--;) {
-        GET_DATA_INDEX(p1, idx1, dtype, x);
-        y = m_abs(x);
-        SET_DATA_INDEX(p2, idx2, rtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p1, idx1, dtype, x);
-        y = m_abs(x);
-        SET_DATA_STRIDE(p2, s2, rtype, y);
-      }
-    }
-  } else {
-    if (idx2) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p1, s1, dtype, x);
-        y = m_abs(x);
-        SET_DATA_INDEX(p2, idx2, rtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p1, s1, dtype, x);
-        y = m_abs(x);
-        SET_DATA_STRIDE(p2, s2, rtype, y);
-      }
-    }
-  }
-}
-
-/*
-  abs of self.
-  @overload abs
-    @return [Numo::UInt16] abs of self.
-*/
-static VALUE uint16_abs(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cRT, 0 } };
-  ndfunc_t ndf = { iter_uint16_abs, FULL_LOOP, 1, 1, ain, aout };
-
-  return na_ndloop(&ndf, 1, self);
-}
-
-static void iter_uint16_poly(na_loop_t* const lp) {
-  size_t i;
-  dtype x, y, a;
-
-  x = *(dtype*)(lp->args[0].ptr + lp->args[0].iter[0].pos);
-  i = lp->narg - 2;
-  y = *(dtype*)(lp->args[i].ptr + lp->args[i].iter[0].pos);
-  for (; --i;) {
-    y = m_mul(x, y);
-    a = *(dtype*)(lp->args[i].ptr + lp->args[i].iter[0].pos);
-    y = m_add(y, a);
-  }
-  i = lp->narg - 1;
-  *(dtype*)(lp->args[i].ptr + lp->args[i].iter[0].pos) = y;
-}
-
-/*
-  Calculate polynomial.
-    `x.poly(a0,a1,a2,...,an) = a0 + a1*x + a2*x**2 + ... + an*x**n`
-  @overload poly a0, a1, ..., an
-    @param [Numo::NArray,Numeric] a0,a1,...,an
-    @return [Numo::UInt16]
-*/
-static VALUE uint16_poly(VALUE self, VALUE args) {
-  int argc, i;
-  VALUE* argv;
-  volatile VALUE v, a;
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf = { iter_uint16_poly, NO_LOOP, 0, 1, 0, aout };
-
-  argc = (int)RARRAY_LEN(args);
-  ndf.nin = argc + 1;
-  ndf.ain = ALLOCA_N(ndfunc_arg_in_t, argc + 1);
-  for (i = 0; i < argc + 1; i++) {
-    ndf.ain[i].type = cT;
-  }
-  argv = ALLOCA_N(VALUE, argc + 1);
-  argv[0] = self;
-  for (i = 0; i < argc; i++) {
-    argv[i + 1] = RARRAY_PTR(args)[i];
-  }
-  a = rb_ary_new4(argc + 1, argv);
-  v = na_ndloop2(&ndf, a);
-  return uint16_extract(v);
-}
-
 /*
   qsort.c
   Ruby/Numo::NArray - Numerical Array class for Ruby
@@ -2254,11 +1853,27 @@ void Init_numo_uint16(void) {
   rb_define_const(cT, "MIN", M_MIN);
   rb_define_alloc_func(cT, uint16_s_alloc_func);
   rb_define_method(cT, "allocate", uint16_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", uint16_extract, 0);
 
   rb_define_method(cT, "store", uint16_store, 1);
 
   rb_define_singleton_method(cT, "cast", uint16_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::UInt16] an element or NArray view.
+   * @see Numo::NArray#[]
+   * @see #[]=
+   */
   rb_define_method(cT, "[]", uint16_aref, -1);
   rb_define_method(cT, "[]=", uint16_aset, -1);
   /**
@@ -2300,10 +1915,54 @@ void Init_numo_uint16(void) {
    *   @return [String]
    */
   rb_define_method(cT, "inspect", uint16_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| ... }`,
+   *   @yieldparam [Numeric] x  an element of NArray.
+   * @see #each_with_index
+   * @see #map
+   */
   rb_define_method(cT, "each", uint16_each, 0);
+  /**
+   * Unary map.
+   * @overload map
+   *   @return [Numo::UInt16] map of self.
+   */
   rb_define_method(cT, "map", uint16_map, 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
+   *   For a block `{|x,i,j,...| ... }`,
+   *   @yieldparam [Numeric] x  an element
+   *   @yieldparam [Integer] i,j,...  multitimensional indices
+   *   @return [Numo::NArray] self
+   * @see #each
+   * @see #map_with_index
+   */
   rb_define_method(cT, "each_with_index", uint16_each_with_index, 0);
+  /**
+   * Invokes the given block once for each element of self,
+   * passing that element and indices along each axis as parameters.
+   * Creates a new NArray containing the values returned by the block.
+   * Inplace option is allowed, i.e., `nary.inplace.map` overwrites `nary`.
+   * @overload map_with_index
+   *   For a block `{|x,i,j,...| ... }`,
+   *   @yieldparam [Numeric] x  an element
+   *   @yieldparam [Integer] i,j,...  multitimensional indices
+   *   @return [Numo::NArray] mapped array
+   * @see #map
+   * @see #each_with_index
+   */
   rb_define_method(cT, "map_with_index", uint16_map_with_index, 0);
+  /**
+   * abs of self.
+   * @overload abs
+   *   @return [Numo::UInt16] abs of self.
+   */
   rb_define_method(cT, "abs", uint16_abs, 0);
   /**
    * Binary add.
@@ -2764,6 +2423,13 @@ void Init_numo_uint16(void) {
    *   # [4, 3, 3, 2, 4, 2]
    */
   rb_define_method(cT, "rand", uint16_rand, -1);
+  /**
+   * Calculate polynomial.
+   *   `x.poly(a0,a1,a2,...,an) = a0 + a1*x + a2*x**2 + ... + an*x**n`
+   * @overload poly a0, a1, ..., an
+   *   @param [Numo::NArray,Numeric] a0,a1,...,an
+   *   @return [Numo::UInt16]
+   */
   rb_define_method(cT, "poly", uint16_poly, -2);
 
   rb_define_method(cT, "sort", uint16_sort, -1);