carray 3.0.2 → 3.0.4

data/ext/ca_obj_timedelta.c

@@ -14,6 +14,7 @@
 --------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"
 #include "ca_obj_face.h"
 
 /* The unit enum is shared with CATime (= same unit system).
@@ -26,7 +27,7 @@ extern void   ca_time_extract_unit (VALUE unit, int8_t *base, int64_t *count);
 typedef struct {
   /* === CAView prefix === */
   int16_t    obj_type;
-  int8_t     data_type;        /* fixed to CA_INT64 */
+  int8_t     data_type;        /* surface: CA_FIXLEN (storage is the int64 parent) */
   int8_t     ndim;
   int32_t    flags;            /* CA_FLAG_IS_FACE set */
   ca_size_t  bytes;            /* fixed to sizeof(int64_t) */
@@ -132,6 +133,21 @@ rb_ca_timedelta_element_initialize (VALUE self, VALUE value, VALUE unit)
   return self;
 }
 
+/* dup / clone copy the value and the unit (the allocator leaves both 0). */
+static VALUE
+rb_ca_timedelta_element_initialize_copy (VALUE self, VALUE orig)
+{
+  CATimedeltaElement *s, *o;
+  if ( self == orig ) {
+    return self;
+  }
+  rb_check_frozen(self);
+  TypedData_Get_Struct(self, CATimedeltaElement, &catimedelta_element_data_type, s);
+  TypedData_Get_Struct(orig, CATimedeltaElement, &catimedelta_element_data_type, o);
+  *s = *o;
+  return self;
+}
+
 static VALUE
 rb_ca_timedelta_element_value (VALUE self)
 {
@@ -161,6 +177,12 @@ ca_timedelta_setup (CATimedelta *ca, CArray *parent, int8_t unit, int64_t count)
              "CATimedelta requires int64 storage (parent.data_type != CA_INT64)");
   }
 
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
+  }
+
   ca->obj_type  = CA_OBJ_TIMEDELTA;
   /* NonNumeric surface (the FIXLEN gate), like CATime: the storage is a
      count of `count x unit` ticks, and letting the numeric kernels read it
@@ -190,9 +212,6 @@ ca_timedelta_setup (CATimedelta *ca, CArray *parent, int8_t unit, int64_t count)
   ca->unit      = unit;
   ca->count     = count;
 
-  if ( ca_has_mask(parent) ) {
-    ca_create_mask((CArray *) ca);
-  }
 
   if ( ca_is_scalar(parent) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
@@ -208,8 +227,11 @@ ca_timedelta_setup (CATimedelta *ca, CArray *parent, int8_t unit, int64_t count)
 CATimedelta *
 ca_timedelta_new (CArray *parent, int8_t unit, int64_t count)
 {
-  CATimedelta *ca = (CATimedelta *) ca_array_alloc(CA_OBJ_TIMEDELTA, parent->ndim);
+  CATimedelta *ca;
+  ca_timedelta_setup(NULL, parent, unit, count);
+  ca = (CATimedelta *) ca_array_alloc(CA_OBJ_TIMEDELTA, parent->ndim);
   ca_timedelta_setup(ca, parent, unit, count);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -246,18 +268,6 @@ ca_timedelta_func_allocate (void *ap)
   ca->ptr = ca->parent->ptr;
 }
 
-static void
-ca_timedelta_func_create_mask (void *ap)
-{
-  CATimedelta *ca = (CATimedelta *) ap;
-  ca_update_mask(ca->parent);
-  if ( ! ca->parent->mask ) {
-    ca_create_mask(ca->parent);
-  }
-  ca->mask = (CArray *) ca_refer_new(ca->parent->mask,
-                                      CA_BOOLEAN, ca->ndim, ca->dim, 0, 0);
-}
-
 ca_operation_function_t ca_timedelta_func = {
   -1, /* CA_OBJ_TIMEDELTA — filled by ca_install_obj_type */
   CA_VIEW_ARRAY,
@@ -268,7 +278,7 @@ ca_operation_function_t ca_timedelta_func = {
   ca_face_sync,
   ca_face_detach,
   ca_face_fill_data,
-  ca_timedelta_func_create_mask,
+  ca_view_func_create_mask,
   ca_face_xfer_index,
   ca_face_xfer_addrs,
   NULL,                              /* fold_stride */
@@ -296,7 +306,7 @@ rb_ca_timedelta_wrap (VALUE parent_val, int8_t unit, int64_t count)
   return obj;
 }
 
-/* __wrap__(raw, unit_spec) — primitive; unit_spec is Symbol / String /
+/* wrap_storage(raw, unit_spec) — primitive; unit_spec is Symbol / String /
    Resolution / nil (normalized here). */
 static VALUE
 rb_ca_timedelta_wrap_method (VALUE klass, VALUE raw, VALUE unit_spec)
@@ -330,20 +340,22 @@ rb_ca_timedelta_initialize_copy (VALUE self, VALUE other)
 {
   CATimedelta *ca, *cs;
   TypedData_Get_Struct(self,  CATimedelta, &catimedelta_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CATimedelta, &catimedelta_data_type, cs);
   if ( ca_func[CA_OBJ_TIMEDELTA].pool_init ) {
     ca_array_pool_alloc(ca, CA_OBJ_TIMEDELTA, cs->parent->ndim);
   }
   ca_timedelta_setup(ca, cs->parent, cs->unit, cs->count);
+  ca_view_inherit_mask((VALUE) ca);
   return self;
 }
 
-/* storage_to_scalar implemented in C to avoid per-cell Ruby method dispatch
+/* storage_to_element implemented in C to avoid per-cell Ruby method dispatch
    on the fetch hot path.  Accepts either an Integer (INT64 surface fetch)
    or an 8-byte String (FIXLEN surface fetch); decodes the parent int64
    and constructs CATimedelta::Element(value, unit). */
 static VALUE
-rb_ca_timedelta_storage_to_scalar (VALUE self, VALUE raw)
+rb_ca_timedelta_storage_to_element (VALUE self, VALUE raw)
 {
   CATimedelta *ca;
   CATimedeltaElement *s;
@@ -355,7 +367,7 @@ rb_ca_timedelta_storage_to_scalar (VALUE self, VALUE raw)
   if ( TYPE(raw) == T_STRING ) {
     if ( RSTRING_LEN(raw) != (long) sizeof(int64_t) ) {
       rb_raise(rb_eArgError,
-               "CATimedelta#storage_to_scalar: expected %lu bytes, got %ld",
+               "CATimedelta#storage_to_element: expected %lu bytes, got %ld",
                (unsigned long) sizeof(int64_t), RSTRING_LEN(raw));
     }
     memcpy(&value, RSTRING_PTR(raw), sizeof(int64_t));
@@ -405,20 +417,20 @@ Init_ca_obj_timedelta (void)
   rb_define_method(rb_cCATimedelta, "initialize_copy",
                                     rb_ca_timedelta_initialize_copy, 1);
 
-  rb_define_singleton_method(rb_cCATimedelta, "__wrap__",
-                                    rb_ca_timedelta_wrap_method, 2);
+  rb_define_private_method(rb_singleton_class(rb_cCATimedelta), "wrap_storage",
+                           rb_ca_timedelta_wrap_method, 2);
   rb_define_method(rb_cCATimedelta, "unit", rb_ca_timedelta_unit, 0);
-  rb_define_method(rb_cCATimedelta, "storage_to_scalar",
-                                    rb_ca_timedelta_storage_to_scalar, 1);
-  /* Registers the state-compatibility predicate so CA_FACE_STORAGE_TO_SCALAR_IF_FACE
+  rb_define_method(rb_cCATimedelta, "storage_to_element",
+                                    rb_ca_timedelta_storage_to_element, 1);
+  /* Registers the state-compatibility predicate so CA_FACE_STORAGE_TO_ELEMENT_IF_FACE
      can skip rb_funcall on the hot path. */
   ca_face_register_state_compatible(CA_OBJ_TIMEDELTA,
                                     ca_timedelta_state_compatible);
   /* unit is pure metadata, no per-parent buffer; multi-parent Face lift
      is safe (portable = 1). */
   ca_face_register_state_portable(CA_OBJ_TIMEDELTA, 1);
-  ca_face_register_storage_to_scalar(CA_OBJ_TIMEDELTA,
-                                     rb_ca_timedelta_storage_to_scalar);
+  ca_face_register_storage_to_element(CA_OBJ_TIMEDELTA,
+                                     rb_ca_timedelta_storage_to_element);
 
   /* CATimedelta::Element as a C-backed TypedData class.  The Ruby-side
      definition in lib/carray/time.rb keeps Comparable + to_seconds /
@@ -430,6 +442,8 @@ Init_ca_obj_timedelta (void)
                        rb_ca_timedelta_element_s_allocate);
   rb_define_method(rb_cCATimedeltaElement, "initialize",
                    rb_ca_timedelta_element_initialize, 2);
+  rb_define_method(rb_cCATimedeltaElement, "initialize_copy",
+                   rb_ca_timedelta_element_initialize_copy, 1);
   rb_define_method(rb_cCATimedeltaElement, "value",
                    rb_ca_timedelta_element_value, 0);
   rb_define_method(rb_cCATimedeltaElement, "unit",

data/ext/ca_obj_transpose.c

@@ -7,6 +7,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"   /* ca_view_inherit_mask */
 #include "ca_obj_face.h"  /* CA_FACE_LIFT_IF_FACE */
 
 extern ca_operation_function_t ca_stride_func;
@@ -37,11 +38,11 @@ ca_trans_setup (CAStride *ca, CArray *parent, ca_size_t *imap)
   for (i = 0; i < ndim; i++) {
     idim = imap[i];
     if (idim < 0 || idim >= ndim) {
-      rb_raise(rb_eRuntimeError,
+      rb_raise(rb_eArgError,
                "specified %i-th dimension number out of range", i);
     }
     if (map[idim] != -1) {
-      rb_raise(rb_eRuntimeError,
+      rb_raise(rb_eArgError,
                "specified %i-th dimension number is duplicated", i);
     }
     map[idim] = i;
@@ -58,17 +59,26 @@ ca_trans_setup (CAStride *ca, CArray *parent, ca_size_t *imap)
     strides[i] = parent_byte_stride[imap[i]];
   }
 
-  ca_stride_setup(ca, CA_OBJ_TRANSPOSE, parent,
-                  parent->data_type, parent->bytes,
-                  ndim, newdim, strides, 0);
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
+  }
+
+  ca_stride_setup_view(ca, CA_OBJ_TRANSPOSE, parent,
+                       parent->data_type, parent->bytes,
+                       ndim, newdim, strides, 0);
   return 0;
 }
 
 CAStride *
 ca_trans_new (CArray *parent, ca_size_t *imap)
 {
-  CAStride *ca = (CAStride *) ca_array_alloc(CA_OBJ_TRANSPOSE, parent->ndim);
+  CAStride *ca;
+  ca_trans_setup(NULL, parent, imap);
+  ca = (CAStride *) ca_array_alloc(CA_OBJ_TRANSPOSE, parent->ndim);
   ca_trans_setup(ca, parent, imap);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -126,6 +136,7 @@ rb_ca_trans_initialize_copy (VALUE self, VALUE other)
 {
   CAStride *ca, *cs;
   TypedData_Get_Struct(self,  CAStride, &castride_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CAStride, &castride_data_type, cs);
   if ( ca_func[CA_OBJ_TRANSPOSE].pool_init ) {
     ca_array_pool_alloc(ca, CA_OBJ_TRANSPOSE, cs->ndim);