carray 3.0.2 → 3.0.4

data/yard-stubs/carray_utils.rb

@@ -67,31 +67,5 @@ class CArray
     def guess_type_and_bytes(type_spec, bytes = nil); end
 
     # @!endgroup
-
-    # @!group String scanning (internal)
-
-    # @overload _scan_float(str, fill_value = nil)
-    #   Parses `str` as a single double-precision float. Returns
-    #   `fill_value` (or `NaN` if `fill_value` is nil) when `str` is
-    #   `nil` or unparseable. Internal helper used by text-format I/O
-    #   readers; end users should prefer Ruby's `Float()` /
-    #   `String#to_f`.
-    #   @param str [String, nil]
-    #   @param fill_value [Float, nil]
-    #   @return [Float]
-    #   @api private
-    def _scan_float(str, fill_value = nil); end
-
-    # @overload _scan_int(str, fill_value = nil)
-    #   Parses `str` as a single integer. Returns `fill_value`
-    #   (or `0` if `fill_value` is nil) when `str` is `nil` or
-    #   unparseable. Internal helper used by text-format I/O readers.
-    #   @param str [String, nil]
-    #   @param fill_value [Integer, nil]
-    #   @return [Integer]
-    #   @api private
-    def _scan_int(str, fill_value = nil); end
-
-    # @!endgroup
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carray
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.0.4
 platform: ruby
 authors:
 - himotoyoshi
@@ -45,7 +45,6 @@ files:
 - ext/ca_composite_dispatch.c
 - ext/ca_composite_dispatch.h
 - ext/ca_for_buffer.h
-- ext/ca_for_each_element.h
 - ext/ca_group_iter.c
 - ext/ca_iter_substrate.h
 - ext/ca_kernel_iterator.c
@@ -96,6 +95,7 @@ files:
 - ext/ca_op_cmplx64.h
 - ext/ca_op_ipower.c
 - ext/ca_op_powi.h
+- ext/ca_pow5_table.h
 - ext/ca_rng_normal.h
 - ext/ca_rng_xoshiro256pp.h
 - ext/ca_sort_kernels.h
@@ -104,6 +104,7 @@ files:
 - ext/ca_transform_common.c
 - ext/ca_triop_dispatch.c
 - ext/ca_triop_dispatch.h
+- ext/caframe_csv_reader.c
 - ext/carray.h
 - ext/carray_access.c
 - ext/carray_address_basis.c
@@ -133,7 +134,6 @@ files:
 - ext/carray_kernels_bincmp.c
 - ext/carray_kernels_binop.c
 - ext/carray_kernels_init.c
-- ext/carray_kernels_map.c
 - ext/carray_kernels_moncmp.c
 - ext/carray_kernels_monop.c
 - ext/carray_kernels_reduce_aggregate.c
@@ -145,6 +145,7 @@ files:
 - ext/carray_kernels_search.c
 - ext/carray_kernels_sort.c
 - ext/carray_kernels_triop.c
+- ext/carray_key_windows.c
 - ext/carray_lazy.c
 - ext/carray_loop.c
 - ext/carray_mask.c
@@ -156,23 +157,26 @@ files:
 - ext/carray_order.c
 - ext/carray_partition.c
 - ext/carray_random.c
+- ext/carray_round.c
 - ext/carray_scatter.c
+- ext/carray_segment.c
 - ext/carray_slab.c
 - ext/carray_slab.h
 - ext/carray_sort.c
 - ext/carray_sort_kernel.c
 - ext/carray_struct.c
 - ext/carray_test.c
+- ext/carray_time_text.c
 - ext/carray_undef.c
 - ext/carray_utils.c
 - ext/extconf.rb
 - ext/mk_call_cfunc.rb
+- ext/mk_pow5_table.rb
 - ext/mkkernel.rb
 - ext/ruby_carray.c
 - ext/version.h
 - ext/version.rb
 - lib/carray.rb
-- lib/carray/arrow_tensor.rb
 - lib/carray/attribute.rb
 - lib/carray/autoload_carray.rb
 - lib/carray/autoload_method_extension.rb
@@ -190,23 +194,29 @@ files:
 - lib/carray/core_extensions.rb
 - lib/carray/data_type_extension.rb
 - lib/carray/data_type_limits.rb
+- lib/carray/distance_limit.rb
 - lib/carray/fixlen_string.rb
 - lib/carray/frame.rb
+- lib/carray/frame/column_verbs.rb
 - lib/carray/frame/concat.rb
 - lib/carray/frame/convert.rb
 - lib/carray/frame/csv_parser.rb
+- lib/carray/frame/describe.rb
 - lib/carray/frame/frame.rb
 - lib/carray/frame/group.rb
 - lib/carray/frame/io.rb
 - lib/carray/frame/join.rb
 - lib/carray/frame/records.rb
+- lib/carray/frame/reshape.rb
 - lib/carray/frame/sort.rb
 - lib/carray/frame/verbs.rb
+- lib/carray/frame/windows.rb
 - lib/carray/fuse_source.rb
 - lib/carray/fusion.rb
 - lib/carray/histogram.rb
 - lib/carray/inspect.rb
 - lib/carray/iterator.rb
+- lib/carray/key_windows.rb
 - lib/carray/lazy.rb
 - lib/carray/mask_gap_fill.rb
 - lib/carray/math.rb
@@ -223,8 +233,10 @@ files:
 - lib/carray/methods/gather_nd.rb
 - lib/carray/methods/index.rb
 - lib/carray/methods/insert_block.rb
+- lib/carray/methods/is_between.rb
 - lib/carray/methods/is_in.rb
 - lib/carray/methods/join.rb
+- lib/carray/methods/lag.rb
 - lib/carray/methods/locate_addr.rb
 - lib/carray/methods/mask_duplicates.rb
 - lib/carray/methods/meshgrid.rb
@@ -237,8 +249,10 @@ files:
 - lib/carray/methods/unique.rb
 - lib/carray/methods/value_counts.rb
 - lib/carray/mkmf.rb
+- lib/carray/record_order.rb
 - lib/carray/rng.rb
 - lib/carray/runtime.rb
+- lib/carray/segment_iterator.rb
 - lib/carray/serialize.rb
 - lib/carray/slab_iterator.rb
 - lib/carray/stack.rb
@@ -246,7 +260,6 @@ files:
 - lib/carray/string_operation_extension.rb
 - lib/carray/struct.rb
 - lib/carray/struct_builder.rb
-- lib/carray/table.rb
 - lib/carray/time.rb
 - lib/carray/window_iterator.rb
 - yard-stubs/ca_obj_array.rb
@@ -286,6 +299,7 @@ files:
 - yard-stubs/carray_order.rb
 - yard-stubs/carray_random.rb
 - yard-stubs/carray_scatter.rb
+- yard-stubs/carray_segment.rb
 - yard-stubs/carray_slab.rb
 - yard-stubs/carray_sort.rb
 - yard-stubs/carray_test.rb

data/ext/ca_for_each_element.h

@@ -1,239 +0,0 @@
-/* ---------------------------------------------------------------------------
- *
- *  ca_for_each_element.h -- sweep ELEMENT macro family (single-array, lexical
- *                            scope body) for ext authors.
- *
- *  PROPOSAL_L0_AUTHOR_SURFACE L0.2a (2026-06-11).  Builds on the sweep engine
- *  helper (ca_sweep_engine.{c,h}, L0.1) for the xfer_all-aware acquire/release
- *  lifecycle.  Provides 5 macro forms for single-array element-wise loops
- *  with author-inline body and lexical-scope state capture.
- *
- *  Forms (Q2 = gamma: READ by-value, INOUT / OUT by-lvalue):
- *
- *    CA_FOR_EACH_ELEMENT(st1, ca, T, x)
- *      Read-only loop; per-iter x = cell value (T rvalue convention but
- *      declared lvalue for assignment).  Mask policy: NO_MASK (raises if
- *      INPUT has mask; use _MASKED form to handle).
- *
- *    CA_FOR_EACH_ELEMENT_MASKED(st1, ca, T, x, m)
- *      Read-only with mask byte m (1 = masked).  Author inspects m and
- *      decides; m == 0 if source has no mask.
- *
- *    CA_FOR_EACH_ELEMENT_INOUT(st2, ca_in, ca_out, T_IN, T_OUT, in, out)
- *      Map kernel; per-iter in = read input, body assigns to out (lvalue),
- *      out is written back to ca_out.  Strict same-shape check on init
- *      (raises on mismatch).  NO_MASK on input.
- *
- *    CA_FOR_EACH_ELEMENT_INOUT_MASKED(st2, ca_in, ca_out, T_IN, T_OUT,
- *                                      in, out, m_in, m_out)
- *      Map kernel with mask; per-iter m_in = input mask byte (or 0 if no
- *      input mask), author writes m_out (1 = mark output cell masked) and
- *      out.  m_out written back to ca_out's mask.
- *
- *    CA_FOR_EACH_ELEMENT_OUT(st1, ca_out, T, out)
- *      Write-only; body assigns to out (lvalue).  Use for init / iota /
- *      fill patterns.  NO_MASK (output mask cleared).
- *
- *  Usage pattern:
- *
- *      ca_each_state_t st;
- *      double x;
- *      CA_FOR_EACH_ELEMENT(st, ca, double, x) {
- *        accumulator += x;
- *      }
- *
- *  Constraints (same as CA_FOR_EACH_FIBER family):
- *    - State (st1 / st2) is author-declared on the stack.
- *    - `break;` from body exits cleanly (release runs in outer for's
- *      teardown clause).
- *    - `return;` from body LEAKS scratch buffers / attached views — do
- *      not return early from the macro body; restructure to break.
- *    - Macros are NOT statement-equivalent (expand to nested for); no
- *      trailing `else`.
- *    - `T` must be the data_type of `ca` (matched via ca->data_type and
- *      ca->bytes — engine does not auto-cast; use rb_ca_wrap_readonly /
- *      rb_ca_template_with_type at the call site if cast needed).
- *
- *  --------------------------------------------------------------------------- */
-
-#ifndef CA_FOR_EACH_ELEMENT_H
-#define CA_FOR_EACH_ELEMENT_H
-
-#include "carray.h"
-#include "ca_sweep_engine.h"
-
-/* Stack-allocated state holders for 1- and 2-operand sweep ELEMENT macros.
- * Embeds the per-op bookkeeping arrays + the core ca_sweep_state_t in one
- * struct so authors declare just one variable. */
-
-typedef struct {
-  CArray       *cx[1];
-  char         *base[1];
-  ca_size_t     stride[1];
-  char         *owned_buf[1];
-  int           attached[1];
-  char         *base_orig[1];
-  ca_sweep_state_t core;
-} ca_each_state_t;
-
-typedef struct {
-  CArray       *cx[2];
-  char         *base[2];
-  ca_size_t     stride[2];
-  char         *owned_buf[2];
-  int           attached[2];
-  char         *base_orig[2];
-  ca_sweep_state_t core;
-} ca_each_map_state_t;
-
-/* Internal init helpers: wire the embedded arrays into core, set fsync /
- * no_mask / src_label.  Called via comma-expression inside the macro
- * for-loop init clause. */
-
-#define CA_SWEEP_WIRE_1_(_st1, _ca0, _fsync, _no_mask, _label) (   \
-    (_st1).cx[0]           = (CArray *)(_ca0),                  \
-    (_st1).core.n_ops      = 1,                                 \
-    (_st1).core.fsync      = (_fsync),                          \
-    (_st1).core.cx         = (_st1).cx,                         \
-    (_st1).core.base       = (_st1).base,                       \
-    (_st1).core.stride     = (_st1).stride,                     \
-    (_st1).core.owned_buf  = (_st1).owned_buf,                  \
-    (_st1).core.attached   = (_st1).attached,                   \
-    (_st1).core.base_orig  = (_st1).base_orig,                  \
-    (_st1).core.no_mask    = (_no_mask),                        \
-    (_st1).core.src_label  = (_label))
-
-#define CA_SWEEP_WIRE_2_(_st2, _ca0, _ca1, _fsync, _no_mask, _label) ( \
-    (_st2).cx[0]           = (CArray *)(_ca0),                  \
-    (_st2).cx[1]           = (CArray *)(_ca1),                  \
-    (_st2).core.n_ops      = 2,                                 \
-    (_st2).core.fsync      = (_fsync),                          \
-    (_st2).core.cx         = (_st2).cx,                         \
-    (_st2).core.base       = (_st2).base,                       \
-    (_st2).core.stride     = (_st2).stride,                     \
-    (_st2).core.owned_buf  = (_st2).owned_buf,                  \
-    (_st2).core.attached   = (_st2).attached,                   \
-    (_st2).core.base_orig  = (_st2).base_orig,                  \
-    (_st2).core.no_mask    = (_no_mask),                        \
-    (_st2).core.src_label  = (_label))
-
-/* ---------- 5 author-facing macro forms ----------
- *
- * All 5 forms expand to a 3-level nested for:
- *   outer  : acquire_chunked / release_chunked (= lifecycle scope)
- *   middle : ca_sweep_next_chunk loop (= chunk iteration)
- *   inner  : per-cell loop within chunk_n
- *
- * Memory peak per AC2: INPUT non-alias views materialise into a single
- * chunk scratch (~32KB at f64).  m0 (= masked form) is chunk-sized too and
- * re-gathered per chunk, so the macro reads at m0[k] -- indexed within the
- * chunk, not by the flat cell index.
- *
- * For MASKED forms (m / m_in / m_out): when source has no mask, m0 is
- * NULL and m / m_in == 0 always.  m_out writes during INOUT_MASKED are
- * silently dropped if no INPUT mask exists (= AC4 mask-creation on
- * INOUT MASKED with no source mask is a future enhancement; current
- * convention follows the FIBER family's MASKED form).
- */
-
-/* (1) READ-only, NO_MASK */
-#define CA_FOR_EACH_ELEMENT(_st1, _ca, T, x)                            \
-  for ( int __cfe_init = (CA_SWEEP_WIRE_1_((_st1), (_ca), "0", 1,          \
-                                        "CA_FOR_EACH_ELEMENT"),         \
-                          ca_sweep_acquire_chunked(&(_st1).core), 1);      \
-        __cfe_init;                                                     \
-        __cfe_init = 0, ca_sweep_release_chunked(&(_st1).core) )           \
-    for ( ; ca_sweep_next_chunk(&(_st1).core); )                           \
-      for ( ca_size_t __cfe_k = 0;                                      \
-            __cfe_k < (_st1).core.chunk_n                               \
-              && (((x) = *(T *)((_st1).core.base[0]                     \
-                                + __cfe_k * (_st1).core.stride[0])), 1); \
-            __cfe_k++ )
-
-/* (2) READ-only, MASKED (m is 1 if masked, 0 otherwise; 0 if no source mask) */
-#define CA_FOR_EACH_ELEMENT_MASKED(_st1, _ca, T, x, m)                  \
-  for ( int __cfem_init = (CA_SWEEP_WIRE_1_((_st1), (_ca), "0", 0,         \
-                                         "CA_FOR_EACH_ELEMENT_MASKED"), \
-                           ca_sweep_acquire_chunked(&(_st1).core), 1);     \
-        __cfem_init;                                                    \
-        __cfem_init = 0, ca_sweep_release_chunked(&(_st1).core) )          \
-    for ( ; ca_sweep_next_chunk(&(_st1).core); )                           \
-      for ( ca_size_t __cfem_k = 0;                                     \
-            __cfem_k < (_st1).core.chunk_n                              \
-              && (((x) = *(T *)((_st1).core.base[0]                     \
-                                + __cfem_k * (_st1).core.stride[0])),   \
-                  ((m) = (_st1).core.m0                                 \
-                            ? (_st1).core.m0[__cfem_k]                  \
-                            : (boolean8_t)0),                           \
-                  1);                                                   \
-            __cfem_k++ )
-
-/* (3) INOUT map (NO_MASK).  Strict same-shape check pre-acquire.        */
-#define CA_FOR_EACH_ELEMENT_INOUT(_st2, _ca_in, _ca_out,                \
-                                  T_IN, T_OUT, in, out)                 \
-  for ( int __cfei_init = (                                             \
-            ca_sweep_check_same_shape((CArray *)(_ca_in),                  \
-                                   (CArray *)(_ca_out),                 \
-                                   "CA_FOR_EACH_ELEMENT_INOUT"),        \
-            CA_SWEEP_WIRE_2_((_st2), (_ca_in), (_ca_out), "01", 1,         \
-                          "CA_FOR_EACH_ELEMENT_INOUT"),                 \
-            ca_sweep_acquire_chunked(&(_st2).core),                        \
-            1);                                                         \
-        __cfei_init;                                                    \
-        __cfei_init = 0, ca_sweep_release_chunked(&(_st2).core) )          \
-    for ( ; ca_sweep_next_chunk(&(_st2).core); )                           \
-      for ( ca_size_t __cfei_k = 0;                                     \
-            __cfei_k < (_st2).core.chunk_n                              \
-              && (((in) = *(T_IN *)((_st2).core.base[0]                 \
-                                    + __cfei_k * (_st2).core.stride[0])), \
-                  1);                                                   \
-            (*(T_OUT *)((_st2).core.base[1]                             \
-                        + __cfei_k * (_st2).core.stride[1]) = (out)),   \
-            __cfei_k++ )
-
-/* (4) INOUT map (MASKED).  Author writes m_out per cell. */
-#define CA_FOR_EACH_ELEMENT_INOUT_MASKED(_st2, _ca_in, _ca_out,         \
-                                         T_IN, T_OUT,                   \
-                                         in, out, m_in, m_out)          \
-  for ( int __cfeim_init = (                                            \
-            ca_sweep_check_same_shape((CArray *)(_ca_in),                  \
-                                   (CArray *)(_ca_out),                 \
-                                   "CA_FOR_EACH_ELEMENT_INOUT_MASKED"), \
-            CA_SWEEP_WIRE_2_((_st2), (_ca_in), (_ca_out), "01", 0,         \
-                          "CA_FOR_EACH_ELEMENT_INOUT_MASKED"),          \
-            ca_sweep_acquire_chunked(&(_st2).core),                        \
-            1);                                                         \
-        __cfeim_init;                                                   \
-        __cfeim_init = 0, ca_sweep_release_chunked(&(_st2).core) )         \
-    for ( ; ca_sweep_next_chunk(&(_st2).core); )                           \
-      for ( ca_size_t __cfeim_k = 0;                                    \
-            __cfeim_k < (_st2).core.chunk_n                             \
-              && (((in) = *(T_IN *)((_st2).core.base[0]                 \
-                                    + __cfeim_k * (_st2).core.stride[0])), \
-                  ((m_in) = (_st2).core.m0                              \
-                              ? (_st2).core.m0[__cfeim_k]               \
-                              : (boolean8_t)0),                         \
-                  ((m_out) = (m_in)),                                   \
-                  1);                                                   \
-            (*(T_OUT *)((_st2).core.base[1]                             \
-                        + __cfeim_k * (_st2).core.stride[1]) = (out)),  \
-            (((_st2).core.m0)                                           \
-                ? ((_st2).core.m0[__cfeim_k] = (m_out))                 \
-                : (boolean8_t)0),                                       \
-            __cfeim_k++ )
-
-/* (5) WRITE-only (init / iota / fill). */
-#define CA_FOR_EACH_ELEMENT_OUT(_st1, _ca_out, T, out)                  \
-  for ( int __cfeo_init = (CA_SWEEP_WIRE_1_((_st1), (_ca_out), "1", 0,     \
-                                         "CA_FOR_EACH_ELEMENT_OUT"),    \
-                           ca_sweep_acquire_chunked(&(_st1).core), 1);     \
-        __cfeo_init;                                                    \
-        __cfeo_init = 0, ca_sweep_release_chunked(&(_st1).core) )          \
-    for ( ; ca_sweep_next_chunk(&(_st1).core); )                           \
-      for ( ca_size_t __cfeo_k = 0;                                     \
-            __cfeo_k < (_st1).core.chunk_n;                             \
-            (*(T *)((_st1).core.base[0]                                 \
-                    + __cfeo_k * (_st1).core.stride[0]) = (out)),       \
-            __cfeo_k++ )
-
-#endif /* CA_FOR_EACH_ELEMENT_H */