numo-narray-alt 0.9.10 → 0.9.12

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

@@ -0,0 +1,130 @@
+#ifndef NUMO_NARRAY_MH_SEQ_H
+#define NUMO_NARRAY_MH_SEQ_H 1
+
+#define DEF_NARRAY_FLT_SEQ_METHOD_FUNC(tDType)                                                 \
+  typedef struct {                                                                             \
+    tDType beg;                                                                                \
+    tDType step;                                                                               \
+    double count;                                                                              \
+  } seq_opt_t;                                                                                 \
+                                                                                               \
+  static void iter_##tDType##_seq(na_loop_t* const lp) {                                       \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    ssize_t s1;                                                                                \
+    size_t* idx1;                                                                              \
+    tDType x;                                                                                  \
+    tDType beg;                                                                                \
+    tDType step;                                                                               \
+    double c;                                                                                  \
+    seq_opt_t* g;                                                                              \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    g = (seq_opt_t*)(lp->opt_ptr);                                                             \
+    beg = g->beg;                                                                              \
+    step = g->step;                                                                            \
+    c = g->count;                                                                              \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = f_seq(beg, step, c++);                                                             \
+        *(tDType*)(p1 + *idx1) = x;                                                            \
+        idx1++;                                                                                \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = f_seq(beg, step, c++);                                                             \
+        *(tDType*)(p1) = x;                                                                    \
+        p1 += s1;                                                                              \
+      }                                                                                        \
+    }                                                                                          \
+    g->count = c;                                                                              \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_seq(int argc, VALUE* args, VALUE self) {                               \
+    seq_opt_t* g;                                                                              \
+    VALUE vbeg = Qnil;                                                                         \
+    VALUE vstep = Qnil;                                                                        \
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };                                             \
+    ndfunc_t ndf = { iter_##tDType##_seq, FULL_LOOP, 1, 0, ain, 0 };                           \
+                                                                                               \
+    g = ALLOCA_N(seq_opt_t, 1);                                                                \
+    g->beg = m_zero;                                                                           \
+    g->step = m_one;                                                                           \
+    g->count = 0;                                                                              \
+    rb_scan_args(argc, args, "02", &vbeg, &vstep);                                             \
+    if (vbeg != Qnil) {                                                                        \
+      g->beg = m_num_to_data(vbeg);                                                            \
+    }                                                                                          \
+    if (vstep != Qnil) {                                                                       \
+      g->step = m_num_to_data(vstep);                                                          \
+    }                                                                                          \
+                                                                                               \
+    na_ndloop3(&ndf, g, 1, self);                                                              \
+    return self;                                                                               \
+  }
+
+#define DEF_NARRAY_INT_SEQ_METHOD_FUNC(tDType)                                                 \
+  typedef struct {                                                                             \
+    double beg;                                                                                \
+    double step;                                                                               \
+    double count;                                                                              \
+  } seq_opt_t;                                                                                 \
+                                                                                               \
+  static void iter_##tDType##_seq(na_loop_t* const lp) {                                       \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    ssize_t s1;                                                                                \
+    size_t* idx1;                                                                              \
+    tDType x;                                                                                  \
+    double beg;                                                                                \
+    double step;                                                                               \
+    double c;                                                                                  \
+    seq_opt_t* g;                                                                              \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    g = (seq_opt_t*)(lp->opt_ptr);                                                             \
+    beg = g->beg;                                                                              \
+    step = g->step;                                                                            \
+    c = g->count;                                                                              \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = f_seq(beg, step, c++);                                                             \
+        *(tDType*)(p1 + *idx1) = x;                                                            \
+        idx1++;                                                                                \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = f_seq(beg, step, c++);                                                             \
+        *(tDType*)(p1) = x;                                                                    \
+        p1 += s1;                                                                              \
+      }                                                                                        \
+    }                                                                                          \
+    g->count = c;                                                                              \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_seq(int argc, VALUE* argv, VALUE self) {                               \
+    seq_opt_t* g;                                                                              \
+    VALUE vbeg = Qnil;                                                                         \
+    VALUE vstep = Qnil;                                                                        \
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };                                             \
+    ndfunc_t ndf = { iter_##tDType##_seq, FULL_LOOP, 1, 0, ain, 0 };                           \
+                                                                                               \
+    g = ALLOCA_N(seq_opt_t, 1);                                                                \
+    g->beg = m_zero;                                                                           \
+    g->step = m_one;                                                                           \
+    g->count = 0;                                                                              \
+    rb_scan_args(argc, argv, "02", &vbeg, &vstep);                                             \
+    if (vbeg != Qnil) {                                                                        \
+      g->beg = NUM2DBL(vbeg);                                                                  \
+    }                                                                                          \
+    if (vstep != Qnil) {                                                                       \
+      g->step = NUM2DBL(vstep);                                                                \
+    }                                                                                          \
+                                                                                               \
+    na_ndloop3(&ndf, g, 1, self);                                                              \
+    return self;                                                                               \
+  }
+
+#endif /* NUMO_NARRAY_MH_SEQ_H */

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

@@ -0,0 +1,69 @@
+#ifndef NUMO_NARRAY_MH_SUM_H
+#define NUMO_NARRAY_MH_SUM_H 1
+
+#define DEF_NARRAY_FLT_SUM_METHOD_FUNC(tDType, tNAryClass)                                     \
+  static void iter_##tDType##_sum(na_loop_t* const lp) {                                       \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    p2 = NDL_PTR(lp, 1);                                                                       \
+                                                                                               \
+    *(tDType*)p2 = f_sum(n, p1, s1);                                                           \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_sum_nan(na_loop_t* const lp) {                                   \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    p2 = NDL_PTR(lp, 1);                                                                       \
+                                                                                               \
+    *(tDType*)p2 = f_sum_nan(n, p1, s1);                                                       \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_sum(int argc, VALUE* argv, VALUE self) {                               \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { sym_reduce, 0 } };                         \
+    ndfunc_arg_out_t aout[1] = { { tNAryClass, 0 } };                                          \
+    ndfunc_t ndf = {                                                                           \
+      iter_##tDType##_sum, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout                  \
+    };                                                                                         \
+    VALUE reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_##tDType##_sum_nan);   \
+    VALUE v = na_ndloop(&ndf, 2, self, reduce);                                                \
+                                                                                               \
+    return rb_funcall(v, rb_intern("extract"), 0);                                             \
+  }
+
+#define DEF_NARRAY_INT_SUM_METHOD_FUNC(tDType, tNAryClass, tRtDType, tRtNAryClass)             \
+  static void iter_##tDType##_sum(na_loop_t* const lp) {                                       \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    p2 = NDL_PTR(lp, 1);                                                                       \
+                                                                                               \
+    *(tRtDType*)p2 = f_sum(n, p1, s1);                                                         \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_sum(int argc, VALUE* argv, VALUE self) {                               \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { sym_reduce, 0 } };                         \
+    ndfunc_arg_out_t aout[1] = { { tRtNAryClass, 0 } };                                        \
+    ndfunc_t ndf = {                                                                           \
+      iter_##tDType##_sum, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout                  \
+    };                                                                                         \
+    VALUE reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);                         \
+    VALUE v = na_ndloop(&ndf, 2, self, reduce);                                                \
+                                                                                               \
+    return rb_funcall(v, rb_intern("extract"), 0);                                             \
+  }
+
+#endif /* NUMO_NARRAY_MH_SUM_H */

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

@@ -0,0 +1,78 @@
+#ifndef NUMO_NARRAY_MH_TO_A_H
+#define NUMO_NARRAY_MH_TO_A_H 1
+
+#define DEF_NARRAY_TO_A_METHOD_FUNC(tDType)                                                    \
+  static void iter_##tDType##_to_a(na_loop_t* const lp) {                                      \
+    size_t n;                                                                                  \
+    size_t s1;                                                                                 \
+    char* p1;                                                                                  \
+    size_t* idx1;                                                                              \
+    tDType x;                                                                                  \
+    volatile VALUE a, y;                                                                       \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    a = rb_ary_new2(n);                                                                        \
+    rb_ary_push(lp->args[1].value, a);                                                         \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        GET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+        y = m_data_to_num(x);                                                                  \
+        rb_ary_push(a, y);                                                                     \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        GET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+        y = m_data_to_num(x);                                                                  \
+        rb_ary_push(a, y);                                                                     \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_to_a(VALUE self) {                                                     \
+    ndfunc_arg_in_t ain[3] = { { Qnil, 0 }, { sym_loop_opt }, { sym_option } };                \
+    ndfunc_arg_out_t aout[1] = { { rb_cArray, 0 } };                                           \
+    ndfunc_t ndf = { iter_##tDType##_to_a, FULL_LOOP_NIP, 3, 1, ain, aout };                   \
+    return na_ndloop_cast_narray_to_rarray(&ndf, self, Qnil);                                  \
+  }
+
+#define DEF_NARRAY_BIT_TO_A_METHOD_FUNC()                                                      \
+  static void iter_bit_to_a(na_loop_t* const lp) {                                             \
+    size_t n;                                                                                  \
+    BIT_DIGIT* a1;                                                                             \
+    size_t p1;                                                                                 \
+    ssize_t s1;                                                                                \
+    size_t* idx1;                                                                              \
+    BIT_DIGIT x = 0;                                                                           \
+    VALUE a;                                                                                   \
+    VALUE y;                                                                                   \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);                                                 \
+    a = rb_ary_new2(n);                                                                        \
+    rb_ary_push(lp->args[1].value, a);                                                         \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        LOAD_BIT(a1, p1 + *idx1, x);                                                           \
+        idx1++;                                                                                \
+        y = m_data_to_num(x);                                                                  \
+        rb_ary_push(a, y);                                                                     \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        LOAD_BIT(a1, p1, x);                                                                   \
+        p1 += s1;                                                                              \
+        y = m_data_to_num(x);                                                                  \
+        rb_ary_push(a, y);                                                                     \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE bit_to_a(VALUE self) {                                                          \
+    ndfunc_arg_in_t ain[3] = { { Qnil, 0 }, { sym_loop_opt }, { sym_option } };                \
+    ndfunc_arg_out_t aout[1] = { { rb_cArray, 0 } };                                           \
+    ndfunc_t ndf = { iter_bit_to_a, FULL_LOOP_NIP, 3, 1, ain, aout };                          \
+    return na_ndloop_cast_narray_to_rarray(&ndf, self, Qnil);                                  \
+  }
+
+#endif /* NUMO_NARRAY_MH_TO_A_H */

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

@@ -31,11 +31,23 @@ static ID id_to_a;
 VALUE cT;
 extern VALUE cRT;
 
+#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/mean.h"
 #include "mh/var.h"
 #include "mh/stddev.h"
 #include "mh/rms.h"
 
+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_MEAN_METHOD_FUNC()
 DEF_NARRAY_BIT_VAR_METHOD_FUNC()
 DEF_NARRAY_BIT_STDDEV_METHOD_FUNC()
@@ -1353,240 +1365,6 @@ static VALUE bit_aset(int argc, VALUE* argv, VALUE self) {
   return argv[argc];
 }
 
-/*
-  return NArray with cast to the type of self.
-  @overload coerce_cast(type)
-    @return [nil]
-*/
-static VALUE bit_coerce_cast(VALUE self, VALUE type) {
-  return Qnil;
-}
-
-static void iter_bit_to_a(na_loop_t* const lp) {
-  size_t i;
-  BIT_DIGIT* a1;
-  size_t p1;
-  ssize_t s1;
-  size_t* idx1;
-  BIT_DIGIT x = 0;
-  VALUE a, y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
-  a = rb_ary_new2(i);
-  rb_ary_push(lp->args[1].value, a);
-  if (idx1) {
-    for (; i--;) {
-      LOAD_BIT(a1, p1 + *idx1, x);
-      idx1++;
-      y = m_data_to_num(x);
-      rb_ary_push(a, y);
-    }
-  } else {
-    for (; i--;) {
-      LOAD_BIT(a1, p1, x);
-      p1 += s1;
-      y = m_data_to_num(x);
-      rb_ary_push(a, y);
-    }
-  }
-}
-
-/*
-  Convert self to Array.
-  @overload to_a
-    @return [Array]
-*/
-static VALUE bit_to_a(VALUE self) {
-  ndfunc_arg_in_t ain[3] = { { Qnil, 0 }, { sym_loop_opt }, { sym_option } };
-  ndfunc_arg_out_t aout[1] = { { rb_cArray, 0 } }; // dummy?
-  ndfunc_t ndf = { iter_bit_to_a, FULL_LOOP_NIP, 3, 1, ain, aout };
-  return na_ndloop_cast_narray_to_rarray(&ndf, self, Qnil);
-}
-
-static void iter_bit_fill(na_loop_t* const lp) {
-  size_t n;
-  size_t p3;
-  ssize_t s3;
-  size_t* idx3;
-  int len;
-  BIT_DIGIT* a3;
-  BIT_DIGIT y;
-  VALUE x = lp->option;
-
-  if (x == INT2FIX(0) || x == Qfalse) {
-    y = 0;
-  } else if (x == INT2FIX(1) || x == Qtrue) {
-    y = ~(BIT_DIGIT)0;
-  } else {
-    rb_raise(rb_eArgError, "invalid value for Bit");
-  }
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR_BIT_IDX(lp, 0, a3, p3, s3, idx3);
-  if (idx3) {
-    y = y & 1;
-    for (; n--;) {
-      STORE_BIT(a3, p3 + *idx3, y);
-      idx3++;
-    }
-  } else if (s3 != 1) {
-    y = y & 1;
-    for (; n--;) {
-      STORE_BIT(a3, p3, y);
-      p3 += s3;
-    }
-  } else {
-    if (p3 > 0 || n < NB) {
-      len = (int)(NB - p3);
-      if ((int)n < len) len = (int)n;
-      *a3 = (y & (SLB(len) << p3)) | (*a3 & ~(SLB(len) << p3));
-      a3++;
-      n -= len;
-    }
-    for (; n >= NB; n -= NB) {
-      *(a3++) = y;
-    }
-    if (n > 0) {
-      *a3 = (y & SLB(n)) | (*a3 & BALL << n);
-    }
-  }
-}
-
-/*
-  Fill elements with other.
-  @overload fill other
-    @param [Numeric] other
-    @return [Numo::Bit] self.
-*/
-static VALUE bit_fill(VALUE self, VALUE val) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { sym_option } };
-  ndfunc_t ndf = { iter_bit_fill, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, val);
-  return self;
-}
-
-static VALUE format_bit(VALUE fmt, dtype x) {
-  if (NIL_P(fmt)) {
-    char s[4];
-    int n;
-    n = m_sprintf(s, x);
-    return rb_str_new(s, n);
-  }
-  return rb_funcall(fmt, '%', 1, m_data_to_num(x));
-}
-
-static void iter_bit_format(na_loop_t* const lp) {
-  size_t i;
-  BIT_DIGIT *a1, x = 0;
-  size_t p1;
-  char* p2;
-  ssize_t s1, s2;
-  size_t* idx1;
-  VALUE y;
-  VALUE fmt = lp->option;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
-  INIT_PTR(lp, 1, p2, s2);
-
-  if (idx1) {
-    for (; i--;) {
-      LOAD_BIT(a1, p1 + *idx1, x);
-      idx1++;
-      y = format_bit(fmt, x);
-      SET_DATA_STRIDE(p2, s2, VALUE, y);
-    }
-  } else {
-    for (; i--;) {
-      LOAD_BIT(a1, p1, x);
-      p1 += s1;
-      y = format_bit(fmt, x);
-      SET_DATA_STRIDE(p2, s2, VALUE, y);
-    }
-  }
-}
-
-/*
-  Format elements into strings.
-  @overload format format
-    @param [String] format
-    @return [Numo::RObject] array of formatted strings.
-*/
-static VALUE bit_format(int argc, VALUE* argv, VALUE self) {
-  VALUE fmt = Qnil;
-
-  ndfunc_arg_in_t ain[2] = { { Qnil, 0 }, { sym_option } };
-  ndfunc_arg_out_t aout[1] = { { numo_cRObject, 0 } };
-  ndfunc_t ndf = { iter_bit_format, FULL_LOOP_NIP, 2, 1, ain, aout };
-
-  rb_scan_args(argc, argv, "01", &fmt);
-  return na_ndloop(&ndf, 2, self, fmt);
-}
-
-static void iter_bit_format_to_a(na_loop_t* const lp) {
-  size_t i;
-  BIT_DIGIT *a1, x = 0;
-  size_t p1;
-  ssize_t s1;
-  size_t* idx1;
-  VALUE y;
-  VALUE fmt = lp->option;
-  volatile VALUE a;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
-  a = rb_ary_new2(i);
-  rb_ary_push(lp->args[1].value, a);
-  if (idx1) {
-    for (; i--;) {
-      LOAD_BIT(a1, p1 + *idx1, x);
-      idx1++;
-      y = format_bit(fmt, x);
-      rb_ary_push(a, y);
-    }
-  } else {
-    for (; i--;) {
-      LOAD_BIT(a1, p1, x);
-      p1 += s1;
-      y = format_bit(fmt, x);
-      rb_ary_push(a, y);
-    }
-  }
-}
-
-/*
-  Format elements into strings.
-  @overload format_to_a format
-    @param [String] format
-    @return [Array] array of formatted strings.
-*/
-static VALUE bit_format_to_a(int argc, VALUE* argv, VALUE self) {
-  VALUE fmt = Qnil;
-  ndfunc_arg_in_t ain[3] = { { Qnil, 0 }, { sym_loop_opt }, { sym_option } };
-  ndfunc_arg_out_t aout[1] = { { rb_cArray, 0 } }; // dummy?
-  ndfunc_t ndf = { iter_bit_format_to_a, FULL_LOOP_NIP, 3, 1, ain, aout };
-
-  rb_scan_args(argc, argv, "01", &fmt);
-  return na_ndloop_cast_narray_to_rarray(&ndf, self, fmt);
-}
-
-static VALUE iter_bit_inspect(char* ptr, size_t pos, VALUE fmt) {
-  dtype x;
-  LOAD_BIT(ptr, pos, x);
-  return format_bit(fmt, x);
-}
-
-/*
-  Returns a string containing a human-readable representation of NArray.
-  @overload inspect
-    @return [String]
-*/
-static VALUE bit_inspect(VALUE ary) {
-  return na_ndloop_inspect(ary, iter_bit_inspect, Qnil);
-}
-
 static void iter_bit_each(na_loop_t* const lp) {
   size_t i;
   BIT_DIGIT *a1, x = 0;
@@ -3222,11 +3000,44 @@ void Init_numo_bit(void) {
   rb_define_singleton_method(cT, "cast", bit_s_cast, 1);
   rb_define_method(cT, "[]", bit_aref, -1);
   rb_define_method(cT, "[]=", bit_aset, -1);
+  /**
+   * return NArray with cast to the type of self.
+   * @overload coerce_cast(type)
+   *   @return [nil]
+   */
   rb_define_method(cT, "coerce_cast", bit_coerce_cast, 1);
+  /**
+   * Convert self to Array.
+   * @overload to_a
+   *   @return [Array]
+   */
   rb_define_method(cT, "to_a", bit_to_a, 0);
+  /**
+   * Fill elements with other.
+   * @overload fill other
+   *   @param [Numeric] other
+   *   @return [Numo::Bit] self.
+   */
   rb_define_method(cT, "fill", bit_fill, 1);
+  /**
+   * Format elements into strings.
+   * @overload format format
+   *   @param [String] format
+   *   @return [Numo::RObject] array of formatted strings.
+   */
   rb_define_method(cT, "format", bit_format, -1);
+  /**
+   * Format elements into strings.
+   * @overload format_to_a format
+   *   @param [String] format
+   *   @return [Array] array of formatted strings.
+   */
   rb_define_method(cT, "format_to_a", bit_format_to_a, -1);
+  /**
+   * Returns a string containing a human-readable representation of NArray.
+   * @overload inspect
+   *   @return [String]
+   */
   rb_define_method(cT, "inspect", bit_inspect, 0);
   rb_define_method(cT, "each", bit_each, 0);
   rb_define_method(cT, "each_with_index", bit_each_with_index, 0);