numo-narray-alt 0.9.10 → 0.9.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: add439c28ff954af644b534f782e947340823412f847c3aadf3c912f8023e497
-  data.tar.gz: fa84b086865ff372d22c9caa2a3ad02101b74047fd3ad9e237aa1d81ac0bb2a2
+  metadata.gz: 90bcb68c4b90224af8196f103f31646f653f9a495ff7b47e24c1f03c3ba8f3d2
+  data.tar.gz: f3105f5bd8c5a2ae27a21ac27f05ad7382a2db76a13529639951ecd98459462b
 SHA512:
-  metadata.gz: 3b84e09af31d5f8cc7ae36ca7ed04382bdb4d31d03352b448d74ccb2004b7cc2f7e95e46873a84b5b5b9e0bbf1bdf63f22b8133391896300063412599ef73ca4
-  data.tar.gz: 3f3ee6430bcce41d3c47ac63bc85b4e7d5c122ddead47c389f7f3e7c74eb68dd76bbc32585a1c360b095cc5a74535376d2793d9d6e9df5f86e1e08ea6f68d23f
+  metadata.gz: 7e81366c927e13e1da39ab2675d9dd11ba75498ee144570728eaf8f9181b471a83d5b7034fdc6e3ce155cbe080f64444c0f17316f64c854d34e950de7b8398b4
+  data.tar.gz: a18a12e36781c4a06f02e2e92835778559e5afa3d3fed7c1b71a257bd7ed91e5523c856db685a1b3c3a527c9dc43f54e229df545a6edfafeaf539c136331ae42

data/Gemfile

@@ -15,7 +15,6 @@ gem 'rubocop-minitest', '~> 0.38.2'
 gem 'rubocop-performance', '~> 1.26'
 gem 'rubocop-rake', '~> 0.7.1'
 gem 'simplecov', '~> 0.22.0'
-gem 'test-unit', '~> 3.7'
 gem 'yard', '~> 0.9.37'
 
 group :memcheck, optional: true do

data/LICENSE

@@ -1,7 +1,7 @@
 BSD 3-Clause License
 
 Copyright (c) 1999-2025, Masahiro TANAKA
-Copyright (c) 2025, Atsushi TATSUMA
+Copyright (c) 2025-2026, Atsushi TATSUMA
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/README.md

@@ -43,6 +43,13 @@ Numo::DFloat#shape=[2,2]
 irb(main):004>
 ```
 
+If you want to explicitly load numo-narray-alt, write the require method as follows:
+
+```ruby
+irb(main):001> require 'numo/narray/alt'
+=> true
+```
+
 ## Documentation
 
 - [API Documentation on Gemdocs](https://gemdocs.org/gems/numo-narray-alt/)

data/ext/numo/narray/numo/narray.h

@@ -13,8 +13,8 @@ extern "C" {
 #endif
 #endif
 
-#define NARRAY_VERSION "0.9.10"
-#define NARRAY_VERSION_CODE 9100
+#define NARRAY_VERSION "0.9.12"
+#define NARRAY_VERSION_CODE 9120
 
 #include <math.h>
 #include "numo/compat.h"

data/ext/numo/narray/numo/types/robj_macro.h

@@ -22,7 +22,7 @@
   {                                                                                            \
     x = rb_funcall(x, id_divmod, 1, y);                                                        \
     a = RARRAY_PTR(x)[0];                                                                      \
-    b = RARRAY_PTR(x)[0];                                                                      \
+    b = RARRAY_PTR(x)[1];                                                                      \
   }
 #define m_pow(x, y) rb_funcall(x, id_pow, 1, y)
 #define m_pow_int(x, y) rb_funcall(x, id_pow, 1, y)

data/ext/numo/narray/numo/types/robject.h

@@ -21,5 +21,5 @@ inline static int robj_nearly_eq(VALUE vx, VALUE vy) {
 
 /* generates a random number on [0,1)-real-interval */
 inline static dtype m_rand(dtype max) {
-  return DBL2NUM(genrand_res53_mix() * max);
+  return DBL2NUM(genrand_res53_mix() * NUM2DBL(max));
 }

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

@@ -0,0 +1,154 @@
+#ifndef NUMO_NARRAY_MH_ARGMAX_H
+#define NUMO_NARRAY_MH_ARGMAX_H 1
+
+#define DEF_NARRAY_FLT_ARGMAX_METHOD_FUNC(tDType)                                              \
+  static void iter_##tDType##_argmax_arg64(na_loop_t* const lp) {                              \
+    size_t n;                                                                                  \
+    size_t idx;                                                                                \
+    char* d_ptr;                                                                               \
+    char* o_ptr;                                                                               \
+    ssize_t d_step;                                                                            \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, d_ptr, d_step);                                                            \
+                                                                                               \
+    idx = f_max_index(n, d_ptr, d_step);                                                       \
+                                                                                               \
+    o_ptr = NDL_PTR(lp, 1);                                                                    \
+    *(int64_t*)o_ptr = (int64_t)idx;                                                           \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_argmax_arg32(na_loop_t* const lp) {                              \
+    size_t n;                                                                                  \
+    size_t idx;                                                                                \
+    char* d_ptr;                                                                               \
+    char* o_ptr;                                                                               \
+    ssize_t d_step;                                                                            \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, d_ptr, d_step);                                                            \
+                                                                                               \
+    idx = f_max_index(n, d_ptr, d_step);                                                       \
+                                                                                               \
+    o_ptr = NDL_PTR(lp, 1);                                                                    \
+    *(int32_t*)o_ptr = (int32_t)idx;                                                           \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_argmax_arg64_nan(na_loop_t* const lp) {                          \
+    size_t n;                                                                                  \
+    size_t idx;                                                                                \
+    char* d_ptr;                                                                               \
+    char* o_ptr;                                                                               \
+    ssize_t d_step;                                                                            \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, d_ptr, d_step);                                                            \
+                                                                                               \
+    idx = f_max_index_nan(n, d_ptr, d_step);                                                   \
+                                                                                               \
+    o_ptr = NDL_PTR(lp, 1);                                                                    \
+    *(int64_t*)o_ptr = (int64_t)idx;                                                           \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_argmax_arg32_nan(na_loop_t* const lp) {                          \
+    size_t n;                                                                                  \
+    size_t idx;                                                                                \
+    char* d_ptr;                                                                               \
+    char* o_ptr;                                                                               \
+    ssize_t d_step;                                                                            \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, d_ptr, d_step);                                                            \
+                                                                                               \
+    idx = f_max_index_nan(n, d_ptr, d_step);                                                   \
+                                                                                               \
+    o_ptr = NDL_PTR(lp, 1);                                                                    \
+    *(int32_t*)o_ptr = (int32_t)idx;                                                           \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_argmax(int argc, VALUE* argv, VALUE self) {                            \
+    narray_t* na;                                                                              \
+    VALUE reduce;                                                                              \
+    ndfunc_arg_in_t ain[2] = { { Qnil, 0 }, { sym_reduce, 0 } };                               \
+    ndfunc_arg_out_t aout[1] = { { 0, 0, 0 } };                                                \
+    ndfunc_t ndf = { 0, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 2, 1, ain, aout };    \
+                                                                                               \
+    GetNArray(self, na);                                                                       \
+    if (na->ndim == 0) {                                                                       \
+      return INT2FIX(0);                                                                       \
+    }                                                                                          \
+                                                                                               \
+    if (na->size > (~(u_int32_t)0)) {                                                          \
+      aout[0].type = numo_cInt64;                                                              \
+      ndf.func = iter_##tDType##_argmax_arg64;                                                 \
+      reduce =                                                                                 \
+        na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_##tDType##_argmax_arg64_nan);     \
+    } else {                                                                                   \
+      aout[0].type = numo_cInt32;                                                              \
+      ndf.func = iter_##tDType##_argmax_arg32;                                                 \
+      reduce =                                                                                 \
+        na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_##tDType##_argmax_arg32_nan);     \
+    }                                                                                          \
+                                                                                               \
+    return na_ndloop(&ndf, 2, self, reduce);                                                   \
+  }
+
+#define DEF_NARRAY_INT_ARGMAX_METHOD_FUNC(tDType)                                              \
+  static void iter_##tDType##_argmax_arg64(na_loop_t* const lp) {                              \
+    size_t n;                                                                                  \
+    size_t idx;                                                                                \
+    char* d_ptr;                                                                               \
+    char* o_ptr;                                                                               \
+    ssize_t d_step;                                                                            \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, d_ptr, d_step);                                                            \
+                                                                                               \
+    idx = f_max_index(n, d_ptr, d_step);                                                       \
+                                                                                               \
+    o_ptr = NDL_PTR(lp, 1);                                                                    \
+    *(int64_t*)o_ptr = (int64_t)idx;                                                           \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_argmax_arg32(na_loop_t* const lp) {                              \
+    size_t n;                                                                                  \
+    size_t idx;                                                                                \
+    char* d_ptr;                                                                               \
+    char* o_ptr;                                                                               \
+    ssize_t d_step;                                                                            \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, d_ptr, d_step);                                                            \
+                                                                                               \
+    idx = f_max_index(n, d_ptr, d_step);                                                       \
+                                                                                               \
+    o_ptr = NDL_PTR(lp, 1);                                                                    \
+    *(int32_t*)o_ptr = (int32_t)idx;                                                           \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_argmax(int argc, VALUE* argv, VALUE self) {                            \
+    narray_t* na;                                                                              \
+    VALUE reduce;                                                                              \
+    ndfunc_arg_in_t ain[2] = { { Qnil, 0 }, { sym_reduce, 0 } };                               \
+    ndfunc_arg_out_t aout[1] = { { 0, 0, 0 } };                                                \
+    ndfunc_t ndf = { 0, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 2, 1, ain, aout };    \
+                                                                                               \
+    GetNArray(self, na);                                                                       \
+    if (na->ndim == 0) {                                                                       \
+      return INT2FIX(0);                                                                       \
+    }                                                                                          \
+                                                                                               \
+    if (na->size > (~(u_int32_t)0)) {                                                          \
+      aout[0].type = numo_cInt64;                                                              \
+      ndf.func = iter_##tDType##_argmax_arg64;                                                 \
+      reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);                             \
+    } else {                                                                                   \
+      aout[0].type = numo_cInt32;                                                              \
+      ndf.func = iter_##tDType##_argmax_arg32;                                                 \
+      reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);                             \
+    }                                                                                          \
+                                                                                               \
+    return na_ndloop(&ndf, 2, self, reduce);                                                   \
+  }
+
+#endif /* NUMO_NARRAY_MH_ARGMAX_H */

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

@@ -0,0 +1,154 @@
+#ifndef NUMO_NARRAY_MH_ARGMIN_H
+#define NUMO_NARRAY_MH_ARGMIN_H 1
+
+#define DEF_NARRAY_FLT_ARGMIN_METHOD_FUNC(tDType)                                              \
+  static void iter_##tDType##_argmin_arg64(na_loop_t* const lp) {                              \
+    size_t n;                                                                                  \
+    size_t idx;                                                                                \
+    char* d_ptr;                                                                               \
+    char* o_ptr;                                                                               \
+    ssize_t d_step;                                                                            \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, d_ptr, d_step);                                                            \
+                                                                                               \
+    idx = f_min_index(n, d_ptr, d_step);                                                       \
+                                                                                               \
+    o_ptr = NDL_PTR(lp, 1);                                                                    \
+    *(int64_t*)o_ptr = (int64_t)idx;                                                           \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_argmin_arg32(na_loop_t* const lp) {                              \
+    size_t n;                                                                                  \
+    size_t idx;                                                                                \
+    char* d_ptr;                                                                               \
+    char* o_ptr;                                                                               \
+    ssize_t d_step;                                                                            \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, d_ptr, d_step);                                                            \
+                                                                                               \
+    idx = f_min_index(n, d_ptr, d_step);                                                       \
+                                                                                               \
+    o_ptr = NDL_PTR(lp, 1);                                                                    \
+    *(int32_t*)o_ptr = (int32_t)idx;                                                           \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_argmin_arg64_nan(na_loop_t* const lp) {                          \
+    size_t n;                                                                                  \
+    size_t idx;                                                                                \
+    char* d_ptr;                                                                               \
+    char* o_ptr;                                                                               \
+    ssize_t d_step;                                                                            \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, d_ptr, d_step);                                                            \
+                                                                                               \
+    idx = f_min_index_nan(n, d_ptr, d_step);                                                   \
+                                                                                               \
+    o_ptr = NDL_PTR(lp, 1);                                                                    \
+    *(int64_t*)o_ptr = (int64_t)idx;                                                           \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_argmin_arg32_nan(na_loop_t* const lp) {                          \
+    size_t n;                                                                                  \
+    size_t idx;                                                                                \
+    char* d_ptr;                                                                               \
+    char* o_ptr;                                                                               \
+    ssize_t d_step;                                                                            \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, d_ptr, d_step);                                                            \
+                                                                                               \
+    idx = f_min_index_nan(n, d_ptr, d_step);                                                   \
+                                                                                               \
+    o_ptr = NDL_PTR(lp, 1);                                                                    \
+    *(int32_t*)o_ptr = (int32_t)idx;                                                           \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_argmin(int argc, VALUE* argv, VALUE self) {                            \
+    narray_t* na;                                                                              \
+    VALUE reduce;                                                                              \
+    ndfunc_arg_in_t ain[2] = { { Qnil, 0 }, { sym_reduce, 0 } };                               \
+    ndfunc_arg_out_t aout[1] = { { 0, 0, 0 } };                                                \
+    ndfunc_t ndf = { 0, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 2, 1, ain, aout };    \
+                                                                                               \
+    GetNArray(self, na);                                                                       \
+    if (na->ndim == 0) {                                                                       \
+      return INT2FIX(0);                                                                       \
+    }                                                                                          \
+                                                                                               \
+    if (na->size > (~(u_int32_t)0)) {                                                          \
+      aout[0].type = numo_cInt64;                                                              \
+      ndf.func = iter_##tDType##_argmin_arg64;                                                 \
+      reduce =                                                                                 \
+        na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_##tDType##_argmin_arg64_nan);     \
+    } else {                                                                                   \
+      aout[0].type = numo_cInt32;                                                              \
+      ndf.func = iter_##tDType##_argmin_arg32;                                                 \
+      reduce =                                                                                 \
+        na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_##tDType##_argmin_arg32_nan);     \
+    }                                                                                          \
+                                                                                               \
+    return na_ndloop(&ndf, 2, self, reduce);                                                   \
+  }
+
+#define DEF_NARRAY_INT_ARGMIN_METHOD_FUNC(tDType)                                              \
+  static void iter_##tDType##_argmin_arg64(na_loop_t* const lp) {                              \
+    size_t n;                                                                                  \
+    size_t idx;                                                                                \
+    char* d_ptr;                                                                               \
+    char* o_ptr;                                                                               \
+    ssize_t d_step;                                                                            \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, d_ptr, d_step);                                                            \
+                                                                                               \
+    idx = f_min_index(n, d_ptr, d_step);                                                       \
+                                                                                               \
+    o_ptr = NDL_PTR(lp, 1);                                                                    \
+    *(int64_t*)o_ptr = (int64_t)idx;                                                           \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_argmin_arg32(na_loop_t* const lp) {                              \
+    size_t n;                                                                                  \
+    size_t idx;                                                                                \
+    char* d_ptr;                                                                               \
+    char* o_ptr;                                                                               \
+    ssize_t d_step;                                                                            \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, d_ptr, d_step);                                                            \
+                                                                                               \
+    idx = f_min_index(n, d_ptr, d_step);                                                       \
+                                                                                               \
+    o_ptr = NDL_PTR(lp, 1);                                                                    \
+    *(int32_t*)o_ptr = (int32_t)idx;                                                           \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_argmin(int argc, VALUE* argv, VALUE self) {                            \
+    narray_t* na;                                                                              \
+    VALUE reduce;                                                                              \
+    ndfunc_arg_in_t ain[2] = { { Qnil, 0 }, { sym_reduce, 0 } };                               \
+    ndfunc_arg_out_t aout[1] = { { 0, 0, 0 } };                                                \
+    ndfunc_t ndf = { 0, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 2, 1, ain, aout };    \
+                                                                                               \
+    GetNArray(self, na);                                                                       \
+    if (na->ndim == 0) {                                                                       \
+      return INT2FIX(0);                                                                       \
+    }                                                                                          \
+                                                                                               \
+    if (na->size > (~(u_int32_t)0)) {                                                          \
+      aout[0].type = numo_cInt64;                                                              \
+      ndf.func = iter_##tDType##_argmin_arg64;                                                 \
+      reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);                             \
+    } else {                                                                                   \
+      aout[0].type = numo_cInt32;                                                              \
+      ndf.func = iter_##tDType##_argmin_arg32;                                                 \
+      reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);                             \
+    }                                                                                          \
+                                                                                               \
+    return na_ndloop(&ndf, 2, self, reduce);                                                   \
+  }
+
+#endif /* NUMO_NARRAY_MH_ARGMIN_H */