cumo 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93c1ecf4d6098da90d957600dc7254e02072999fa33374951809cb8c4f5645ee
-  data.tar.gz: f8961f11f4b8feed097fbfbe3fe0603e270f8f1b44121c112c506e42cefc2bf1
+  metadata.gz: 17cb9dfdf9be41292bcd0204a67c5f919da60588d005d4441ad632767dce504c
+  data.tar.gz: 4c6e388cdb5b3b9f99d45a989a610d63e493fe53b3baad570c7bb2656f72d86c
 SHA512:
-  metadata.gz: df0b42ff21e2158657e0d8a86872f9e85a6af7ab6ae09c7dfc4368d71001846c7f087633bfa2f6071bdd43f910da041470a43694c2aa2c37c74b5ff684e85c88
-  data.tar.gz: 95572510fbc31633f423db010c9135271c5ded4bfda28c5f07734b90d76e9fd36fa8c2af0bdd1d03151df2eba93aa3f07c61d6d39aa2f8c7d011364a7ee99615
+  metadata.gz: 917adaa087836d673a143364f88fb9ddf91ad84cbcc064b115258e32f4b22e70a63c45f3e655a2e56ad58e70d6a4330f3e63ce177b5ad9e0a0c9c11685b39503
+  data.tar.gz: c5ec5a4179266a1cf4c5f15b5bc0d7e8b0b01a5a69bb7a75ad3c1387e861666da8b571156bc90295f2cf702558f18e332ce7fd68823330f834ea8d9c4f8b6419

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2025-12-29 17:31:25 UTC using RuboCop version 1.82.1.
+# on 2026-01-09 18:33:26 UTC using RuboCop version 1.82.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -371,7 +371,7 @@ Lint/ConstantDefinitionInBlock:
   Exclude:
     - 'test/cuda/compiler_test.rb'
 
-# Offense count: 650
+# Offense count: 665
 # Configuration parameters: Only, Ignore.
 Lint/ConstantResolution:
   Enabled: false
@@ -388,7 +388,7 @@ Lint/ErbNewArguments:
   Exclude:
     - 'ext/cumo/narray/gen/erbpp2.rb'
 
-# Offense count: 7
+# Offense count: 15
 Lint/FloatComparison:
   Exclude:
     - 'test/narray_test.rb'
@@ -411,7 +411,7 @@ Lint/NonAtomicFileOperation:
   Exclude:
     - 'lib/cumo/cuda/compiler.rb'
 
-# Offense count: 26
+# Offense count: 34
 # This cop supports unsafe autocorrection (--autocorrect-all).
 # Configuration parameters: AllowedMethods, AllowedPatterns, IgnoredClasses.
 # IgnoredClasses: Time, DateTime
@@ -424,6 +424,7 @@ Lint/NumberConversion:
     - 'ext/cumo/narray/gen/erbln.rb'
     - 'lib/cumo/narray/extra.rb'
     - 'test/cudnn_test.rb'
+    - 'test/narray_test.rb'
 
 # Offense count: 2
 # This cop supports safe autocorrection (--autocorrect).

data/3rd_party/mkmf-cu/lib/mkmf-cu/cli.rb

@@ -38,33 +38,33 @@ module MakeMakefileCuda
       cmd = "nvcc #{s}"
       if ENV['CUMO_NVCC_GENERATE_CODE']
         cmd << " --generate-code=#{ENV['CUMO_NVCC_GENERATE_CODE']}"
-      elsif ENV['DEBUG']
-        cmd << " -arch=sm_35"
       else
-        # Ref. https://en.wikipedia.org/wiki/CUDA
-        if cuda_version >= Gem::Version.new("13.0")
-          # CUDA 13.0
-          capability = [75, 87, 89, 90, 121]
-        elsif cuda_version >= Gem::Version.new("12.9")
-          # CUDA 12.9
-          capability = [50, 60, 70, 75, 87, 89, 90, 121]
-        elsif cuda_version >= Gem::Version.new("12.8")
-          # CUDA 12.8
-          capability = [50, 60, 70, 75, 87, 89, 90, 120]
-        elsif cuda_version >= Gem::Version.new("12.0")
-          # CUDA 12.0 – 12.6
-          capability = [50, 60, 70, 75, 87, 89, 90]
-        elsif cuda_version >= Gem::Version.new("11.8")
-          # CUDA 11.8
-          capability = [35, 50, 60, 70, 75, 87, 89, 90]
-        else
-          # CUDA 11.0
-          capability = [35, 50, 60, 70, 75, 80]
-        end
-
+        capability = nil
         if find_executable('nvidia-smi')
           arch_version = `nvidia-smi --query-gpu=compute_cap --format=csv,noheader`.strip
-          capability << (arch_version.to_f * 10).to_i unless arch_version.empty?
+          capability = [(arch_version.to_f * 10).to_i] unless arch_version.empty?
+        end
+        unless capability
+          # Ref. https://en.wikipedia.org/wiki/CUDA
+          if cuda_version >= Gem::Version.new("13.0")
+            # CUDA 13.0
+            capability = [75, 80, 86, 87, 89, 90, 100, 103, 110, 120, 121]
+          elsif cuda_version >= Gem::Version.new("12.9")
+            # CUDA 12.9
+            capability = [50, 60, 61, 62, 70, 72, 75, 80, 86, 87, 89, 90, 100, 103, 110, 120, 121]
+          elsif cuda_version >= Gem::Version.new("12.8")
+            # CUDA 12.8
+            capability = [50, 60, 61, 62, 70, 72, 75, 80, 86, 87, 89, 90, 100, 103, 110, 120]
+          elsif cuda_version >= Gem::Version.new("12.0")
+            # CUDA 12.0 – 12.6
+            capability = [50, 60, 61, 62, 70, 72, 75, 80, 86, 87, 89, 90]
+          elsif cuda_version >= Gem::Version.new("11.8")
+            # CUDA 11.8
+            capability = [35, 50, 60, 61, 62, 70, 72, 75, 80, 86, 87, 89, 90]
+          else
+            # CUDA 11.0
+            capability = [35, 50, 60, 61, 62, 70, 72, 75, 80]
+          end
         end
 
         capability.each do |arch|

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 0.5.2 (2025/01/25)
+
+Fixes:
+
+* Backport: Add support for copy on write with store_binary and frozen string
+* Remove unnecessary debug code
+* Fix capability list
+* Build only with supported capabilities to reduce compilation time
+* Fix SEGV when calling {mean, var, stddev, rms} on a single-element array (#154)
+* Suppress warning message for deprecated declarations
+* Fix variable typo in complex log2 and log10 functions (#152)
+
 # 0.5.1 (2025/12/30)
 
 Enhancements:

data/ext/cumo/include/cumo/cuda/cumo_thrust.hpp

@@ -26,7 +26,7 @@ class cumo_thrust_strided_range
 {
     public:
 
-    typedef typename thrust::iterator_difference<Iterator>::type difference_type;
+    typedef typename thrust::iterator_traits<Iterator>::difference_type difference_type;
 
     struct stride_functor
     {

data/ext/cumo/include/cumo/narray.h

@@ -226,6 +226,7 @@ typedef struct {
 typedef struct {
     cumo_narray_t base;
     char    *ptr;
+    bool     owned;
 } cumo_narray_data_t;
 
 
@@ -360,6 +361,7 @@ _cumo_na_get_narray_t(VALUE obj, unsigned char cumo_na_type)
 #define CUMO_NA_DATA(na)             ((cumo_narray_data_t*)(na))
 #define CUMO_NA_VIEW(na)             ((cumo_narray_view_t*)(na))
 #define CUMO_NA_DATA_PTR(na)         (CUMO_NA_DATA(na)->ptr)
+#define CUMO_NA_DATA_OWNED(na)       (CUMO_NA_DATA(na)->owned)
 #define CUMO_NA_VIEW_DATA(na)        (CUMO_NA_VIEW(na)->data)
 #define CUMO_NA_VIEW_OFFSET(na)      (CUMO_NA_VIEW(na)->offset)
 #define CUMO_NA_VIEW_STRIDX(na)      (CUMO_NA_VIEW(na)->stridx)

data/ext/cumo/include/cumo/types/complex.h

@@ -166,14 +166,14 @@ static inline dtype c_log(dtype x) {
 static inline dtype c_log2(dtype x) {
     dtype z;
     z = c_log(x);
-    z = c_mul_r(x,M_LOG2E);
+    z = c_mul_r(z,M_LOG2E);
     return z;
 }
 
 static inline dtype c_log10(dtype x) {
     dtype z;
     z = c_log(x);
-    z = c_mul_r(x,M_LOG10E);
+    z = c_mul_r(z,M_LOG10E);
     return z;
 }
 

data/ext/cumo/include/cumo.h

@@ -10,7 +10,7 @@ extern "C" {
 #endif
 #endif
 
-#define CUMO_VERSION "0.5.1"
+#define CUMO_VERSION "0.5.2"
 #define CUMO_VERSION_CODE 51
 
 bool cumo_compatible_mode_enabled_p();

data/ext/cumo/narray/gen/tmpl/alloc_func.c

@@ -29,7 +29,9 @@ static void
     assert(na->base.type == CUMO_NARRAY_DATA_T);
 
     if (na->ptr != NULL) {
-        cumo_cuda_runtime_free(na->ptr);
+        if (na->owned) {
+            cumo_cuda_runtime_free(na->ptr);
+        }
         na->ptr = NULL;
     }
     if (na->base.size > 0) {
@@ -103,5 +105,6 @@ static VALUE
     na->base.shape = NULL;
     na->base.reduce = INT2FIX(0);
     na->ptr = NULL;
+    na->owned = FALSE;
     return TypedData_Wrap_Struct(klass, &<%=type_name%>_data_type, (void*)na);
 }

data/ext/cumo/narray/gen/tmpl/allocate.c

@@ -22,6 +22,7 @@ static VALUE
             ptr = cumo_cuda_runtime_malloc(sizeof(dtype) * na->size);
             <% end %>
             CUMO_NA_DATA_PTR(na) = ptr;
+            CUMO_NA_DATA_OWNED(na) = TRUE;
         }
         break;
     case CUMO_NARRAY_VIEW_T:

data/ext/cumo/narray/gen/tmpl/complex_accum_kernel.cu

@@ -79,10 +79,10 @@ void cumo_<%=type_name%>_mean_kernel_launch(uint64_t n, char *p1, ssize_t s1, ch
 {
     ssize_t s1_idx = s1 / sizeof(dtype);
     thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
-    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
-    if (s1_idx == 1) {
-        cumo_<%=type_name%>_mean_kernel<<<1,1>>>(data_begin, data_end, (dtype*)p2, n);
+    if (s1_idx == 1 || n == 1) {
+        cumo_<%=type_name%>_mean_kernel<<<1,1>>>(data_begin, data_begin + n, (dtype*)p2, n);
     } else {
+        thrust::device_ptr<dtype> data_end = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
         cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
         cumo_<%=type_name%>_mean_kernel<<<1,1>>>(range.begin(), range.end(), (dtype*)p2, n);
     }
@@ -92,10 +92,10 @@ void cumo_<%=type_name%>_var_kernel_launch(uint64_t n, char *p1, ssize_t s1, cha
 {
     ssize_t s1_idx = s1 / sizeof(dtype);
     thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
-    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
-    if (s1_idx == 1) {
-        cumo_<%=type_name%>_var_kernel<<<1,1>>>(data_begin, data_end, (rtype*)p2);
+    if (s1_idx == 1 || n == 1) {
+        cumo_<%=type_name%>_var_kernel<<<1,1>>>(data_begin, data_begin + n, (rtype*)p2);
     } else {
+    thrust::device_ptr<dtype> data_end = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
         cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
         cumo_<%=type_name%>_var_kernel<<<1,1>>>(range.begin(), range.end(), (rtype*)p2);
     }
@@ -105,10 +105,10 @@ void cumo_<%=type_name%>_stddev_kernel_launch(uint64_t n, char *p1, ssize_t s1,
 {
     ssize_t s1_idx = s1 / sizeof(dtype);
     thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
-    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
-    if (s1_idx == 1) {
-        cumo_<%=type_name%>_stddev_kernel<<<1,1>>>(data_begin, data_end, (rtype*)p2);
+    if (s1_idx == 1 || n == 1) {
+        cumo_<%=type_name%>_stddev_kernel<<<1,1>>>(data_begin, data_begin + n, (rtype*)p2);
     } else {
+        thrust::device_ptr<dtype> data_end = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
         cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
         cumo_<%=type_name%>_stddev_kernel<<<1,1>>>(range.begin(), range.end(), (rtype*)p2);
     }
@@ -118,10 +118,10 @@ void cumo_<%=type_name%>_rms_kernel_launch(uint64_t n, char *p1, ssize_t s1, cha
 {
     ssize_t s1_idx = s1 / sizeof(dtype);
     thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
-    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
-    if (s1_idx == 1) {
-        cumo_<%=type_name%>_rms_kernel<<<1,1>>>(data_begin, data_end, (rtype*)p2, n);
+    if (s1_idx == 1 || n == 1) {
+        cumo_<%=type_name%>_rms_kernel<<<1,1>>>(data_begin, data_begin + n, (rtype*)p2, n);
     } else {
+        thrust::device_ptr<dtype> data_end = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
         cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
         cumo_<%=type_name%>_rms_kernel<<<1,1>>>(range.begin(), range.end(), (rtype*)p2, n);
     }

data/ext/cumo/narray/gen/tmpl/float_accum_kernel.cu

@@ -57,10 +57,10 @@ void cumo_<%=type_name%>_mean_kernel_launch(uint64_t n, char *p1, ssize_t s1, ch
 {
     ssize_t s1_idx = s1 / sizeof(dtype);
     thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
-    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
-    if (s1_idx == 1) {
-        cumo_<%=type_name%>_mean_kernel<<<1,1>>>(data_begin, data_end, (<%=dtype%>*)p2, n);
+    if (s1_idx == 1 || n == 1) {
+        cumo_<%=type_name%>_mean_kernel<<<1,1>>>(data_begin, data_begin + n, (<%=dtype%>*)p2, n);
     } else {
+        thrust::device_ptr<dtype> data_end = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
         cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
         cumo_<%=type_name%>_mean_kernel<<<1,1>>>(range.begin(), range.end(), (<%=dtype%>*)p2, n);
     }
@@ -70,10 +70,10 @@ void cumo_<%=type_name%>_var_kernel_launch(uint64_t n, char *p1, ssize_t s1, cha
 {
     ssize_t s1_idx = s1 / sizeof(dtype);
     thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
-    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
-    if (s1_idx == 1) {
-        cumo_<%=type_name%>_var_kernel<<<1,1>>>(data_begin, data_end, (<%=dtype%>*)p2);
+    if (s1_idx == 1 || n == 1) {
+        cumo_<%=type_name%>_var_kernel<<<1,1>>>(data_begin, data_begin + n, (<%=dtype%>*)p2);
     } else {
+        thrust::device_ptr<dtype> data_end = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
         cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
         cumo_<%=type_name%>_var_kernel<<<1,1>>>(range.begin(), range.end(), (<%=dtype%>*)p2);
     }
@@ -83,10 +83,10 @@ void cumo_<%=type_name%>_stddev_kernel_launch(uint64_t n, char *p1, ssize_t s1,
 {
     ssize_t s1_idx = s1 / sizeof(dtype);
     thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
-    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
-    if (s1_idx == 1) {
-        cumo_<%=type_name%>_stddev_kernel<<<1,1>>>(data_begin, data_end, (<%=dtype%>*)p2);
+    if (s1_idx == 1 || n == 1) {
+        cumo_<%=type_name%>_stddev_kernel<<<1,1>>>(data_begin, data_begin + n, (<%=dtype%>*)p2);
     } else {
+        thrust::device_ptr<dtype> data_end = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
         cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
         cumo_<%=type_name%>_stddev_kernel<<<1,1>>>(range.begin(), range.end(), (<%=dtype%>*)p2);
     }
@@ -96,10 +96,10 @@ void cumo_<%=type_name%>_rms_kernel_launch(uint64_t n, char *p1, ssize_t s1, cha
 {
     ssize_t s1_idx = s1 / sizeof(dtype);
     thrust::device_ptr<dtype> data_begin = thrust::device_pointer_cast((dtype*)p1);
-    thrust::device_ptr<dtype> data_end   = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
-    if (s1_idx == 1) {
-        cumo_<%=type_name%>_rms_kernel<<<1,1>>>(data_begin, data_end, (<%=dtype%>*)p2, n);
+    if (s1_idx == 1 || n == 1) {
+        cumo_<%=type_name%>_rms_kernel<<<1,1>>>(data_begin, data_begin + n, (<%=dtype%>*)p2, n);
     } else {
+        thrust::device_ptr<dtype> data_end = thrust::device_pointer_cast(((dtype*)p1) + n * s1_idx);
         cumo_thrust_strided_range<thrust::device_vector<dtype>::iterator> range(data_begin, data_end, s1_idx);
         cumo_<%=type_name%>_rms_kernel<<<1,1>>>(range.begin(), range.end(), (<%=dtype%>*)p2, n);
     }

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

@@ -12,6 +12,7 @@ static VALUE
         if (na->size > 0 && ptr == NULL) {
             ptr = cumo_cuda_runtime_malloc(((na->size-1)/8/sizeof(CUMO_BIT_DIGIT)+1)*sizeof(CUMO_BIT_DIGIT));
             CUMO_NA_DATA_PTR(na) = ptr;
+            CUMO_NA_DATA_OWNED(na) = TRUE;
         }
         break;
     case CUMO_NARRAY_VIEW_T:

data/ext/cumo/narray/narray.c

@@ -34,6 +34,7 @@ static ID cumo_id_count_false_cpu;
 static ID cumo_id_axis;
 static ID cumo_id_nan;
 static ID cumo_id_keepdims;
+static ID cumo_id_source;
 
 VALUE cumo_sym_reduce;
 VALUE cumo_sym_option;
@@ -577,6 +578,87 @@ cumo_na_s_eye(int argc, VALUE *argv, VALUE klass)
 #define READ 1
 #define WRITE 2
 
+static void
+cumo_na_set_pointer(VALUE self, char *ptr, size_t byte_size)
+{
+    VALUE obj;
+    cumo_narray_t *na;
+
+    if (OBJ_FROZEN(self)) {
+        rb_raise(rb_eRuntimeError, "cannot write to frozen NArray.");
+    }
+
+    CumoGetNArray(self,na);
+
+    switch(CUMO_NA_TYPE(na)) {
+    case CUMO_NARRAY_DATA_T:
+        if (CUMO_NA_SIZE(na) > 0) {
+            if (CUMO_NA_DATA_PTR(na) != NULL && CUMO_NA_DATA_OWNED(na)) {
+                xfree(CUMO_NA_DATA_PTR(na));
+            }
+            CUMO_NA_DATA_PTR(na) = ptr;
+            CUMO_NA_DATA_OWNED(na) = FALSE;
+        }
+        return;
+    case CUMO_NARRAY_VIEW_T:
+        obj = CUMO_NA_VIEW_DATA(na);
+        if (OBJ_FROZEN(obj)) {
+            rb_raise(rb_eRuntimeError, "cannot write to frozen NArray.");
+        }
+        CumoGetNArray(obj,na);
+        switch(CUMO_NA_TYPE(na)) {
+        case CUMO_NARRAY_DATA_T:
+            if (CUMO_NA_SIZE(na) > 0) {
+                if (CUMO_NA_DATA_PTR(na) != NULL && CUMO_NA_DATA_OWNED(na)) {
+                    xfree(CUMO_NA_DATA_PTR(na));
+                }
+                CUMO_NA_DATA_PTR(na) = ptr;
+                CUMO_NA_DATA_OWNED(na) = FALSE;
+            }
+            return;
+        default:
+            rb_raise(rb_eRuntimeError,"invalid NA_TYPE of view: %d",CUMO_NA_TYPE(na));
+        }
+    default:
+        rb_raise(rb_eRuntimeError,"invalid NA_TYPE: %d",CUMO_NA_TYPE(na));
+    }
+}
+
+static void
+cumo_na_pointer_copy_on_write(VALUE self)
+{
+    cumo_narray_t *na;
+    void *ptr;
+    VALUE velmsz;
+    size_t byte_size;
+
+    CumoGetNArray(self,na);
+    if (CUMO_NA_TYPE(na) == CUMO_NARRAY_VIEW_T) {
+        self = CUMO_NA_VIEW_DATA(na);
+        CumoGetNArray(self,na);
+    }
+
+    ptr = CUMO_NA_DATA_PTR(na);
+    if (ptr == NULL) {
+        return;
+    }
+
+    if (CUMO_NA_DATA_OWNED(na)) {
+        return;
+    }
+
+    velmsz = rb_const_get(rb_obj_class(self), cumo_id_element_byte_size);
+    if (FIXNUM_P(velmsz)) {
+        byte_size = CUMO_NA_SIZE(na) * NUM2SIZET(velmsz);
+    } else {
+        byte_size = ceil(CUMO_NA_SIZE(na) * NUM2DBL(velmsz));
+    }
+    CUMO_NA_DATA_PTR(na) = NULL;
+    rb_funcall(self, cumo_id_allocate, 0);
+    memcpy(CUMO_NA_DATA_PTR(na), ptr, byte_size);
+    rb_ivar_set(self, cumo_id_source, Qnil);
+}
+
 static char *
 cumo_na_get_pointer_for_rw(VALUE self, int flag)
 {
@@ -592,6 +674,9 @@ cumo_na_get_pointer_for_rw(VALUE self, int flag)
 
     switch(CUMO_NA_TYPE(na)) {
     case CUMO_NARRAY_DATA_T:
+        if (flag & WRITE) {
+            cumo_na_pointer_copy_on_write(self);
+        }
         ptr = CUMO_NA_DATA_PTR(na);
         if (CUMO_NA_SIZE(na) > 0 && ptr == NULL) {
             if (flag & READ) {
@@ -608,6 +693,9 @@ cumo_na_get_pointer_for_rw(VALUE self, int flag)
         if ((flag & WRITE) && OBJ_FROZEN(obj)) {
             rb_raise(rb_eRuntimeError, "cannot write to frozen NArray.");
         }
+        if (flag & WRITE) {
+            cumo_na_pointer_copy_on_write(self);
+        }
         CumoGetNArray(obj,na);
         switch(CUMO_NA_TYPE(na)) {
         case CUMO_NARRAY_DATA_T:
@@ -1313,7 +1401,6 @@ static VALUE
 cumo_na_store_binary(int argc, VALUE *argv, VALUE self)
 {
     size_t size, str_len, byte_size, offset;
-    char *ptr;
     int   narg;
     VALUE vstr, voffset;
     VALUE velmsz;
@@ -1343,8 +1430,13 @@ cumo_na_store_binary(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "string is too short to store");
     }
 
-    ptr = cumo_na_get_pointer_for_write(self);
-    memcpy(ptr, RSTRING_PTR(vstr)+offset, byte_size);
+    if (OBJ_FROZEN(vstr)) {
+        cumo_na_set_pointer(self, RSTRING_PTR(vstr)+offset, byte_size);
+        rb_ivar_set(self, cumo_id_source, vstr);
+    } else {
+        void *ptr = cumo_na_get_pointer_for_write(self);
+        memcpy(ptr, RSTRING_PTR(vstr)+offset, byte_size);
+    }
 
     return SIZET2NUM(byte_size);
 }
@@ -1456,6 +1548,7 @@ cumo_na_marshal_load(VALUE self, VALUE a)
         ptr = cumo_na_get_pointer_for_write(self);
         memcpy(ptr, RARRAY_PTR(v), CUMO_NA_SIZE(na)*sizeof(VALUE));
     } else {
+        rb_str_freeze(v);
         cumo_na_store_binary(1,&v,self);
         if (CUMO_TEST_BYTE_SWAPPED(self)) {
             rb_funcall(cumo_na_inplace(self),cumo_id_to_host,0);
@@ -2023,6 +2116,7 @@ Init_cumo_narray()
     cumo_id_axis            = rb_intern("axis");
     cumo_id_nan             = rb_intern("nan");
     cumo_id_keepdims        = rb_intern("keepdims");
+    cumo_id_source          = rb_intern("source");
 
     cumo_sym_reduce   = ID2SYM(rb_intern("reduce"));
     cumo_sym_option   = ID2SYM(rb_intern("option"));

data/test/narray_test.rb

@@ -736,10 +736,90 @@ class NArrayTest < Test::Unit::TestCase
       at.at([0, 1], [0, 1]).inplace - 1
       assert { at == [[0, 2, 3], [4, 4, 6]] }
     end
+
+    sub_test_case "#{dtype}.from_binary" do
+      test "frozen string" do
+        shape = [2, 5]
+        a = dtype.new(*shape)
+        a.rand(0, 10)
+        original_data = a.to_binary
+        data = original_data.dup.freeze
+        restored_a = dtype.from_binary(data, shape)
+        assert { restored_a == a }
+        restored_a[0, 0] += 1
+        assert { restored_a != a }
+        assert { data == original_data }
+      end
+
+      test "not frozen string" do
+        shape = [2, 5]
+        a = dtype.new(*shape)
+        a.rand(0, 10)
+        original_data = a.to_binary
+        data = original_data.dup
+        restored_a = dtype.from_binary(data, shape)
+        assert { restored_a == a }
+        restored_a[0, 0] += 1
+        assert { restored_a != a }
+        assert { data == original_data }
+      end
+    end
+
+    sub_test_case "#{dtype}#store_binary" do
+      test "frozen string" do
+        shape = [2, 5]
+        a = dtype.new(*shape)
+        a.rand(0, 10)
+        original_data = a.to_binary
+        data = original_data.dup.freeze
+        restored_a = dtype.new(*shape)
+        restored_a.store_binary(data)
+        assert { restored_a == a }
+        restored_a[0, 0] += 1
+        assert { restored_a != a }
+        assert { data == original_data }
+      end
+
+      test "not frozen string" do
+        shape = [2, 5]
+        a = dtype.new(*shape)
+        a.rand(0, 10)
+        original_data = a.to_binary
+        data = original_data.dup
+        restored_a = dtype.new(*shape)
+        restored_a.store_binary(data)
+        assert { restored_a == a }
+        restored_a[0, 0] += 1
+        assert { restored_a != a }
+        assert { data == original_data }
+      end
+    end
   end
 
   test "Cumo::DFloat.cast(Cumo::RObject[1, nil, 3])" do
     assert_equal(Cumo::DFloat[1, Float::NAN, 3].format_to_a,
                  Cumo::DFloat.cast(Cumo::RObject[1, nil, 3]).format_to_a)
   end
+
+  test "single element array" do
+    assert { Cumo::SFloat[1].mean == 1.0 }
+    assert { Cumo::DFloat[1].mean == 1.0 }
+    assert { Cumo::SComplex[1].mean == 1.0 }
+    assert { Cumo::DComplex[1].mean == 1.0 }
+
+    assert { Cumo::SFloat[1].var.to_f.nan? }
+    assert { Cumo::DFloat[1].var.to_f.nan? }
+    assert { Cumo::SComplex[1].var.to_f.nan? }
+    assert { Cumo::DComplex[1].var.to_f.nan? }
+
+    assert { Cumo::SFloat[1].stddev.to_f.nan? }
+    assert { Cumo::DFloat[1].stddev.to_f.nan? }
+    assert { Cumo::SComplex[1].stddev.to_f.nan? }
+    assert { Cumo::DComplex[1].stddev.to_f.nan? }
+
+    assert { Cumo::SFloat[1].rms == 1.0 }
+    assert { Cumo::DFloat[1].rms == 1.0 }
+    assert { Cumo::SComplex[1].rms == 1.0 }
+    assert { Cumo::DComplex[1].rms == 1.0 }
+  end
 end

data/test/ractor_test.rb

@@ -10,7 +10,7 @@ class NArrayRactorTest < CumoTestBase
       dtype = data.fetch(:dtype)
       ary = random_array(dtype)
       r = Ractor.new(ary) { |x| x }
-      ary2 = r.take
+      ary2 = r.respond_to?(:take) ? r.take : r.value
       assert_equal(ary, ary2)
       assert_not_same(ary, ary2)
     end
@@ -22,7 +22,7 @@ class NArrayRactorTest < CumoTestBase
       r = Ractor.new(ary1) do |ary2|
         [ary2, ary2 * 10]
       end
-      ary2, res = r.take
+      ary2, res = r.respond_to?(:take) ? r.take : r.value
       assert_equal((dtype != Cumo::RObject),
                    ary1.equal?(ary2))
       assert_equal(ary1 * 10, res)
@@ -37,7 +37,9 @@ class NArrayRactorTest < CumoTestBase
       r2 = Ractor.new(ary1) do |ary4|
         ary4 * 10
       end
-      assert_equal(r1.take, r2.take)
+      result1 = r1.respond_to?(:take) ? r1.take : r1.value
+      result2 = r2.respond_to?(:take) ? r2.take : r2.value
+      assert_equal(result1, result2)
     end
 
     def random_array(dtype, n=1000)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cumo
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - Naotoshi Seo
@@ -331,7 +331,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.4
 specification_version: 4
 summary: Cumo is CUDA aware numerical library whose interface is highly compatible
   with Ruby Numo