carray 3.0.1 → 3.0.3

data/ext/ruby_carray.c

@@ -44,6 +44,7 @@ void Init_carray_access ();
 void Init_carray_index_classifier ();
 void Init_carray_element ();
 void Init_carray_scatter ();     /* scatter_*! family */
+void Init_carray_segment ();     /* segment lengths / offsets / index */
 void Init_ca_axis_group ();      /* devel/MEMO_AXIS_GROUP.md — axis-group reduction kernel */
 void Init_ca_group_iter ();      /* devel/MEMO_AXIS_GROUP.md — axis-group [] surface */
 void Init_carray_bincount ();    /* bincount dedicated kernel */
@@ -89,6 +90,8 @@ void Init_ca_obj_byte_swap ();
 void Init_ca_face ();            /* CAFace abstract base; must precede CATime / CATimedelta / CARecord / CAConstString */
 void Init_ca_source ();          /* CASource abstract base; concrete sources live in C extensions */
 void Init_ca_obj_time ();  /* first numeric Face */
+void Init_carray_time_text ();
+void Init_caframe_csv_reader ();
 void Init_ca_obj_timedelta ();   /* CATime sibling */
 void Init_ca_obj_record ();      /* composite Face for CAStruct backing */
 void Init_ca_obj_const_string ();/* read-only variable-length string Face */
@@ -121,6 +124,13 @@ void Init_ca_kernel_iterator ();
 
 void Init_carray_slab ();
 
+void Init_carray_address_basis (); /* CArray::AddressBasis: pointer + byte
+                                      strides lent for the length of a block,
+                                      for code that addresses cells itself.
+                                      A runtime facility at the ca_attach
+                                      layer, not a user surface; see
+                                      guides/devel/21_address_basis.md */
+
 void
 Init_carray_ext (void)
 {
@@ -162,7 +172,7 @@ Init_carray_ext (void)
   /* -- Exception class -- */
 
   rb_eCADataTypeError =
-    rb_define_class_under(rb_cCArray, "DataTypeError", rb_eStandardError);
+    rb_define_class_under(rb_cCArray, "DataTypeError", rb_eTypeError);
 
   /* -- CA module -- namespace for misc utilities related to CArray */
 
@@ -279,6 +289,7 @@ Init_carray_ext (void)
   Init_carray_index_classifier();
   Init_carray_element();
   Init_carray_scatter();
+  Init_carray_segment();
   Init_ca_axis_group();    /* devel/MEMO_AXIS_GROUP.md — axis-group reduction kernel */
   Init_carray_bincount();
   Init_carray_factorize();
@@ -310,7 +321,7 @@ Init_carray_ext (void)
   Init_ca_obj_refer();
   Init_ca_obj_stride();       /* CAREFUL: must precede CAStride subclasses
                                  (farray / block / transpose / repeat /
-                                 unbound_repeat / field). */
+                                 field). */
   Init_ca_obj_farray();
   Init_ca_obj_block();
   Init_ca_obj_select();
@@ -336,6 +347,8 @@ Init_carray_ext (void)
                                  (datetime / timedelta / record /
                                  const_string). */
   Init_ca_obj_time();
+  Init_carray_time_text();
+  Init_caframe_csv_reader();
   Init_ca_obj_timedelta();
   Init_ca_obj_record();
   Init_ca_obj_const_string();
@@ -373,5 +386,7 @@ Init_carray_ext (void)
   Init_ca_kernel_iterator();
 
   Init_carray_slab();
+
+  Init_carray_address_basis();
 }
 

data/ext/version.h

@@ -1,6 +1,6 @@
-#define CA_VERSION "3.0.1"
-#define CA_VERSION_CODE 301
+#define CA_VERSION "3.0.3"
+#define CA_VERSION_CODE 30003
 #define CA_VERSION_MAJOR 3
 #define CA_VERSION_MINOR 0
-#define CA_VERSION_TEENY 1
-#define CA_VERSION_DATE "2026/09/07"
+#define CA_VERSION_TEENY 3
+#define CA_VERSION_DATE "2026/10/13"

data/ext/version.rb

@@ -21,8 +21,10 @@ def carray_version
 
   ca_version2 = format("%i.%i.%i", 
                        ca_version_major, ca_version_minor, ca_version_teeny)
-  ca_version_code2 = 
-            100 * ca_version_major + 10*ca_version_minor + ca_version_teeny
+  # Two decimal digits for each of minor and teeny, so 3.0.10 (30010)
+  # comes after 3.0.9 (30009) and before 3.1.0 (30100).
+  ca_version_code2 =
+            10000 * ca_version_major + 100 * ca_version_minor + ca_version_teeny
 
   # Allow pre-release suffix like "3.0.0.dev" / "3.0.0.alpha1" while still
   # validating the numeric MAJOR.MINOR.TEENY prefix.

data/lib/carray/attribute.rb

@@ -4,6 +4,7 @@
 #  Surface:
 #    ca.attr(:unit)             # => getter; nil if absent
 #    ca.set_attr(:unit, "m/s")  # => setter; writes to self's @attr
+#    ca.set_attrs(other.attrs)  # => sets every key of a Hash at once
 #    ca.attrs                   # => frozen shallow clone of the full Hash
 #    ca.has_attr?               # => any attribute present?
 #    ca.has_attr?(:unit)        # => specific key present?
@@ -27,6 +28,14 @@
 #    `attrs` returns the effective merged Hash (deeper writes
 #    override shallower ones), frozen.
 #    Setter side always writes to self's @attr.
+#    The walk stops at a lazy operation view (CAMonOp / CABinOp /
+#    CATriOp / CAMonCmp / CABinCmp): its cells are computed, not the
+#    parent's cells, so the parent's attributes do not describe them.
+#    `a.lazy` itself (CALazyMarker) is a view of `a` and walks through.
+#
+#  Copies: `copy` and `to_type` give the new array the attributes the
+#  source shows, as its own Hash.  Arithmetic and reductions do not
+#  carry them -- the result is a different quantity.
 
 class CArray
 
@@ -61,6 +70,30 @@ class CArray
     (@attr ||= {})[attr_normalize_key(key)] = attr_coerce_value(value)
   end
 
+  # @overload set_attrs(hash)
+  #   Sets every key of `hash` on `self`, as {#set_attr} does one key.
+  #   Keys already on `self` and not in `hash` are kept. Every value is
+  #   validated before any is written, so a rejected value leaves `self`
+  #   unchanged. `b.set_attrs(a.attrs)` gives `b` the attributes `a`
+  #   shows.
+  #   @param hash [Hash{Symbol, String => Object}] attributes to set.
+  #   @return [CArray] self.
+  #   @raise [TypeError] when a key or a value is not accepted.
+  def set_attrs (hash)
+    unless hash.is_a?(Hash)
+      raise TypeError, "set_attrs takes a Hash (got #{hash.class})"
+    end
+    entries = hash.map do |key, value|
+      attr_validate_value(value)
+      [attr_normalize_key(key), attr_coerce_value(value)]
+    end
+    unless entries.empty?
+      h = (@attr ||= {})
+      entries.each { |k, v| h[k] = v }
+    end
+    self
+  end
+
   # @overload attrs
   #   Returns a frozen shallow Hash of all attributes visible on
   #   `self`, merged along the parent chain (deeper writes shadow
@@ -114,6 +147,7 @@ class CArray
         h = ca.instance_variable_get(:@attr)
         yield(h) if h
       end
+      return nil if attr_computing_view?(ca)
       parent = ca.respond_to?(:parent) ? ca.parent : nil
       return nil if parent.nil? || parent.equal?(ca)
       ca = parent
@@ -121,6 +155,11 @@ class CArray
     nil
   end
 
+  def attr_computing_view? (ca)
+    ca.is_a?(CAMonOp) || ca.is_a?(CABinOp) || ca.is_a?(CATriOp) ||
+      ca.is_a?(CAMonCmp) || ca.is_a?(CABinCmp)
+  end
+
   def attr_normalize_key (key)
     case key
     when String then key

data/lib/carray/autoload_carray.rb

@@ -30,8 +30,9 @@
 
 class CArray
   inspect_rb = "carray/inspect"
-  autoload_method "inspect",     inspect_rb
-  autoload_method "source_code", inspect_rb
+  autoload_method "inspect",      inspect_rb
+  autoload_method "inspect_full", inspect_rb
+  autoload_method "source_code",  inspect_rb
 end
 
 # ---- Serializer / Marshal / dump / load ------------------------------------
@@ -42,11 +43,27 @@ class CArray
   autoload_method "self.save",           serialize_rb
   autoload_method "self.load",           serialize_rb
   autoload_method "self.dump",           serialize_rb
-  autoload_method "self.load_from_file", serialize_rb
   autoload_method "marshal_dump",        serialize_rb
   autoload_method "marshal_load",        serialize_rb
 end
 
+# A view, a wrap and a scalar are marshalled through _dump / self._load,
+# which return a new array: with marshal_dump Marshal records the class and
+# loads into an empty instance of it, which the plain array the payload
+# holds cannot become.  A record array keeps marshal_dump, under which it
+# already round-trips with its class.
+[CAView, CAWrap, CScalar].each do |klass|
+  klass.class_eval do
+    undef_method :marshal_dump
+    autoload_method "_dump",               "carray/serialize"
+    autoload_method "self._load",          "carray/serialize"
+  end
+end
+
+class CARecord
+  autoload_method "marshal_dump",        "carray/serialize"
+end
+
 # ---- Arrow tensor IPC (interop) --------------------------------------------
 
 class CArray
@@ -126,10 +143,12 @@ class CArray
   categorical_iterator_rb = "carray/categorical_iterator"
   autoload_method "group_by_category", categorical_iterator_rb
   autoload_method "group_by_run", categorical_iterator_rb
+  autoload_method "segments", "carray/segment_iterator"
 end
 
 autoload :CACategorical,          "carray/categorical"
 autoload :CACategoricalIterator,  "carray/categorical_iterator"
+autoload :CASegmentIterator,      "carray/segment_iterator"
 autoload :AxisGroup,              "carray/axis_group"
 autoload :GroupLabels,            "carray/axis_group"
 
@@ -201,11 +220,13 @@ class CArray
   autoload_method "self.meshgrid",  "carray/methods/meshgrid"
 
   autoload_method "bincount",       "carray/methods/bincount"
+  autoload_method "repeat",         "carray/methods/repeat"
   autoload_method "self.broadcast", "carray/methods/broadcast"
   autoload_method "gather_nd",      "carray/methods/gather_nd"
   autoload_method "put_nd",         "carray/methods/gather_nd"
   autoload_method "mask_duplicates", "carray/methods/mask_duplicates"
   autoload_method "unique",          "carray/methods/unique"
+  autoload_method "factorize",       "carray/methods/factorize"
   autoload_method "is_in",           "carray/methods/is_in"
   autoload_method "intersection",    "carray/methods/is_in"
   autoload_method "difference",      "carray/methods/is_in"

data/lib/carray/autoload_method_extension.rb

@@ -32,6 +32,7 @@ module AutoloadMethodExtension
   private
 
   def autoload_define (target, name, library, original_spec)
+    stub = nil
     target.define_method(name) do |*args, **kwargs, &block|
       begin
         require library
@@ -39,7 +40,24 @@ module AutoloadMethodExtension
         raise "error in autoloading '#{library}' hooked by method " \
               "'#{original_spec}', check gem installation."
       end
+      # The require is supposed to have replaced this stub with the real
+      # definition. If it has not, the method does not exist anywhere, and
+      # forwarding would land straight back here and keep doing so until the
+      # stack gave out -- naming neither the method nor the library. Say
+      # which, once.
+      if target.instance_method(name) == stub
+        raise NoMethodError,
+              "'#{original_spec}' is registered for autoload from " \
+              "'#{library}', but that library defines no such method"
+      end
       send(name, *args, **kwargs, &block)
     end
+    stub = target.instance_method(name)
+    # The library replaces the stub with a plain `def`, which `ruby -w`
+    # reports as a redefinition.  Replacing is what the stub is for, so mark
+    # it as aliased: Ruby does not warn when the old definition has an alias.
+    tmp = :"__autoload_stub_#{name}__"
+    target.send(:alias_method, tmp, name)
+    target.send(:remove_method, tmp)
   end
 end

data/lib/carray/axis_group.rb

@@ -213,6 +213,57 @@ class AxisGroup
     end
   end
 
+  # The keywords a group reduction takes besides axis:.  Checked before the
+  # work, so an unknown keyword is refused rather than dropped.
+  REDUCE_KEYWORDS = [:axis, :min_count, :fill_value].freeze
+
+  # all / any take axis: only, as the core ones do.
+  LOGICAL_REDUCE_KEYWORDS = [:axis].freeze
+
+  def self.__check_reduce_keywords__ (op, kw)
+    allowed = [:all, :any].include?(op.to_sym) ? LOGICAL_REDUCE_KEYWORDS : REDUCE_KEYWORDS
+    unknown = kw.keys - allowed
+    unless unknown.empty?
+      raise ArgumentError,
+            "#{op}: unknown keyword#{unknown.size > 1 ? "s" : ""}: " +
+            unknown.map(&:inspect).join(", ")
+    end
+    CArray.__min_count_need__(op, kw[:min_count], 0)
+    nil
+  end
+
+  # A boolean array carrying value's mask: what a count reads, for a value
+  # whose payload the group kernel cannot read.
+  def self.__count_stand_in__ (value)
+    return value if value.boolean? || value.integer? || value.float?
+    stand_in = CArray.boolean(*value.shape)
+    stand_in.mask = value.mask if value.has_mask?
+    stand_in
+  end
+
+  # A count of the mask reads every cell of the group, as the core's does.
+  MASK_COUNTS = [:count, :count_not_masked, :count_masked].freeze
+
+  # min_count: masks a group with fewer contributing cells (present cells,
+  # or every cell for a count of the mask); fill_value: then fills the masked
+  # cells -- as a core reduction does with each.
+  def self.__finish_reduction__ (iter, op, kw, result)
+    need = CArray.__min_count_need__(op, kw[:min_count], 0)
+    if need > 0
+      counts = if MASK_COUNTS.include?(op.to_sym)
+                 iter.elements(axis: kw[:axis])
+               else
+                 iter.count_not_masked(axis: kw[:axis])
+               end
+      if result.is_a?(CArray)
+        result[counts.lt(need)] = UNDEF
+      elsif counts < need
+        result = UNDEF
+      end
+    end
+    CArray.__reduce_fill__(result, kw[:fill_value])
+  end
+
   # Parse an axis: spec into [has_group, fused_band_slot_positions].
   def self.parse_axis (axis)
     has_group = false
@@ -308,7 +359,70 @@ end
 # / min / max / variance / stddev / variancep / stddevp / count /
 # count_not_masked / all / any) bind in C to one driver; the rest of the common
 # iterator surface that composes cheaply from those is added here.
+# CAGroupIterator subclasses CAIterator, but the class itself is created in
+# C, so the reopening below carries no superclass for YARD to read.
+# @!parse class CAGroupIterator < CAIterator; end
 class CAGroupIterator
+  # The shape one value per piece comes back in: a group slot contributes its
+  # category count, a band slot its length, in slot order. The base declares
+  # these and every other member answers them; this one inherited the readers
+  # without anything ever setting the ivars, so it answered nil -- which the
+  # base's own rule calls out as the one thing a member must not do ("a clean
+  # NotImplementedError, never a wrong answer").
+  def shape
+    spec.slot_meta.map { |m| m[:kind] == :group ? m[:k] : m[:len] }
+  end
+  alias dim shape
+
+  def ndim
+    spec.nslots
+  end
+
+  # The C dispatcher every reduction shares takes keywords only, so the
+  # value-equality and masked forms the base declares -- count(v), count(UNDEF)
+  # -- arrived as "wrong number of arguments", which reads as a method that
+  # does not take one rather than one whose engine has no such fold. Both are
+  # composed here instead, out of folds the engine does have.
+  alias __count_present__ count
+
+  # @overload count
+  #   Per-group count of present (non-masked) cells.
+  # @overload count(UNDEF)
+  #   Per-group count of masked cells, as {#count_masked}.
+  # @overload count(v)
+  #   Per-group count of cells equal to `v`.
+  #   @return [CArray]
+  def count (*args, **kw)
+    return __count_present__(**kw) if args.empty?
+    if args.size > 1
+      raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0..1)"
+    end
+    v = args.first
+    return count_masked(**kw) if v.equal?(UNDEF)
+    # eq leaves a masked cell UNDEF, so the sum leaves it out and its
+    # min_count: counts the present cells, as the core count(v) does
+    self.class.__build__(value.eq(v).int64, spec).sum(**kw).int64
+  end
+
+  alias __all_folded__ all
+  alias __any_folded__ any
+
+  # @overload all
+  #   Per-group `all` over a boolean payload.
+  #   @return [CArray]
+  def all (**kw)
+    boolean_payload!(:all)
+    __all_folded__(**kw)
+  end
+
+  # @overload any
+  #   Per-group `any` over a boolean payload.
+  #   @return [CArray]
+  def any (**kw)
+    boolean_payload!(:any)
+    __any_folded__(**kw)
+  end
+
   # Per-group classified cell count (mask-independent) = count on the
   # mask-stripped value, so every classified cell is counted regardless of the
   # value mask (unlike count / count_not_masked, which count present cells).
@@ -318,7 +432,30 @@ class CAGroupIterator
 
   # Per-group count of value-masked cells = elements - count_not_masked.
   def count_masked (**kw)
-    elements(**kw) - count_not_masked(**kw)
+    has_group, = AxisGroup.parse_axis(kw[:axis])
+    return value.count_masked(**kw) unless has_group
+    AxisGroup.__check_reduce_keywords__(:count_masked, kw)
+    plain = { axis: kw[:axis] }
+    AxisGroup.__finish_reduction__(self, :count_masked, kw,
+                                   elements(**plain) - count_not_masked(**plain))
+  end
+
+  # The scatter kernel reads an integer or float payload, and answers there
+  # as the core does. Any other payload -- boolean, complex, object, a Face --
+  # is reduced group by group by the core, through the composite categorical,
+  # so the data type, the Face and a refusal are the core's: a boolean's sum
+  # is uint64, a time column's minimum a time, its sum refused.
+  [:sum, :accumulate, :prod, :mean, :min, :max,
+   :variance, :stddev, :variancep, :stddevp].each do |op|
+    alias_method :"__#{op}_by_kernel__", op
+    define_method(op) do |**kw|
+      has_group, = AxisGroup.parse_axis(kw[:axis])
+      if ! has_group || kernel_reads_value?
+        __send__(:"__#{op}_by_kernel__", **kw)
+      else
+        reduce_by_core(op, kw)
+      end
+    end
   end
 
   # Per-group [min, max] pair (matching CArray#minmax).
@@ -362,13 +499,21 @@ class CAGroupIterator
   # (no present pair) is UNDEF (matching CArray#wmean); a present group whose
   # weights sum to zero yields NaN/Inf (core's 0/0).
   def wmean (weights, **kw)
+    has_group, = AxisGroup.parse_axis(kw[:axis])
+    return value.wmean(weights, **kw) unless has_group
+    AxisGroup.__check_reduce_keywords__(:wmean, kw)
+    plain = { axis: kw[:axis] }
     prod = value * weights
-    num  = self.class.__build__(prod, spec).sum(**kw)
-    den  = self.class.__build__(value * 0 + weights, spec).sum(**kw)
-    cnt  = self.class.__build__(prod, spec).count_not_masked(**kw)
-    out  = num / den
-    out[cnt.eq(0)] = UNDEF          # no present pair -> masked (empty group)
-    out
+    num  = self.class.__build__(prod, spec).sum(**plain)
+    den  = self.class.__build__(value * 0 + weights, spec).sum(**plain)
+    cnt  = self.class.__build__(prod, spec).count_not_masked(**plain)
+    # No present pair is UNDEF (an empty group), set on the denominator so
+    # the division never meets an empty group's 0 / 0.
+    den  = den.copy
+    den[cnt.eq(0)] = UNDEF
+    # min_count: counts the present pairs, as the core wmean does.
+    pairs = self.class.__build__(prod, spec)
+    AxisGroup.__finish_reduction__(pairs, :wmean, kw, num / den)
   end
 
   # ---- segment scan: within-group running statistics ---------------------
@@ -504,12 +649,13 @@ class CAGroupIterator
     raise LocalJumpError, "no block given (yield)" unless block
     ccat, _kd, gslots, bslots, gaxes = composite_layout
     return value.group_by_category(ccat).map(data_type: data_type, &block) if bslots.empty?
-    dt  = data_type || value.data_type
-    out = CArray.new(dt, value.shape)
+    out = nil
     each_band_block(ccat, gslots, bslots, gaxes) do |val_idx, _oi, _co, gi|
-      out[*val_idx] = gi.map(data_type: dt, &block)
+      result = gi.map(data_type: data_type, &block)
+      out ||= blank_of(result, value.shape)
+      out[*val_idx] = result
     end
-    out
+    out || (data_type ? CArray.new(data_type, value.shape) : blank_of(value, value.shape))
   end
 
   # @overload reduce { |members| ... }
@@ -549,6 +695,18 @@ class CAGroupIterator
   # (the shape a length-K result reshapes to). This is the classification the C
   # scatter kernel computes on the fly, materialised once so the order
   # statistics / iterate / sort_addr can hold each group's members together.
+  # Whether a payload folds with all / any is the core's call, not this
+  # engine's. The engine counts any non-zero numeric cell as true, which made
+  # the group the one member of the family that answered where CArray#all and
+  # every sibling refuse -- so `data.all` and `data[g].all(axis: :group)` on
+  # the same float array disagreed about whether the question was even
+  # askable. Asking a one-cell array of the same data type lets the core's own
+  # refusal through, unworded by us.
+  def boolean_payload! (op)
+    CArray.new(value.data_type, [1], bytes: value.bytes).public_send(op)
+    nil
+  end
+
   def composite_layout
     gslots = spec.slot_meta.select { |m| m[:kind] == :group }
     bslots = spec.slot_meta.select { |m| m[:kind] == :band }
@@ -619,10 +777,71 @@ class CAGroupIterator
             "axis_group scan: folding a band into a scan (axis: [:group, k]) " \
             "is not supported; a scan preserves the source shape"
     end
+    return scan_by_core(op) unless kernel_scans?(op)
     group_axes, bundles, = spec.reduce_plan([])
     value.__axis_group_scan__(group_axes, bundles, op)
   end
 
+  # Whether the scatter kernels read this payload: an integer or a float,
+  # not a Face. They answer there in the core's data types.
+  def kernel_reads_value?
+    ! value.face? && (value.integer? || value.float?)
+  end
+
+  # Whether the scan kernel gives the core's answer: it reads an integer,
+  # float, boolean or object payload (not a complex, not a Face), and answers cumsum / cumprod in
+  # float64 (an object in object), cummax / cummin in the payload's data type
+  # and cumcount in int64 -- not the core's answer for a boolean's running sum.
+  def kernel_scans? (op)
+    return false if value.face? || value.complex?
+    return true if value.object? || op == :cumcount
+    core = CArray.new(value.data_type, [1], bytes: value.bytes).public_send(op).data_type
+    kernel = [:cumsum, :cumprod].include?(op) ? CA_FLOAT64 : value.data_type
+    core == kernel
+  end
+
+  # A scan the kernel does not answer as the core does: each group block is
+  # grouped through the composite categorical, whose scans are the core's.
+  def scan_by_core (op)
+    ccat, _kd, gslots, bslots, gaxes = composite_layout
+    return value.group_by_category(ccat).public_send(op) if bslots.empty?
+    out = nil
+    each_band_block(ccat, gslots, bslots, gaxes) do |val_idx, _oi, _co, gi|
+      result = gi.public_send(op)
+      out ||= blank_of(result, value.shape)
+      out[*val_idx] = result
+    end
+    out || blank_of(value, value.shape)
+  end
+
+  # A reduction of a payload the scatter kernel does not read, group by
+  # group through the composite categorical. Folding a band into the
+  # statistic needs the kernel.
+  def reduce_by_core (op, kw)
+    _, fused = AxisGroup.parse_axis(kw[:axis])
+    unless fused.empty?
+      raise ArgumentError,
+            "axis_group #{op}: folding a band into the statistic " \
+            "(axis: [:group, k]) is not supported for a #{value.class} of " \
+            "data type #{value.data_type_name}"
+    end
+    AxisGroup.__check_reduce_keywords__(op, kw)
+    AxisGroup.__finish_reduction__(self, op, kw, composite_order(op, []))
+  end
+
+  # An array of +shape+ of the same kind as +model+ -- its data type, or its
+  # Face -- with every cell UNDEF. A read-only Face cannot be written cell by
+  # cell, so its values are held in an object array.
+  def blank_of (model, shape)
+    out = if model.face? && model.read_only?
+            CArray.new(CA_OBJECT, shape)
+          else
+            model.__send__(:__blank_like__, shape)
+          end
+    out[] = UNDEF
+    out
+  end
+
   # Dispatch an order statistic (median / percentile / quantile). No :group ->
   # plain value reduction; :group -> per-group order statistics via the composite
   # materialize. Folding a band into an order statistic (axis: [:group, k])
@@ -630,13 +849,19 @@ class CAGroupIterator
   # operation, and remains a follow-up.
   def order_stat (op, args, kw)
     has_group, fused = AxisGroup.parse_axis(kw[:axis])
-    return value.public_send(op, *args) unless has_group
+    return value.public_send(op, *args, **kw) unless has_group
     unless fused.empty?
       raise NotImplementedError,
             "axis_group: folding a band into an order statistic (axis: [:group, k]) " \
             "is not supported; order statistics gather every member of a group"
     end
-    composite_order(op, args)
+    AxisGroup.__check_reduce_keywords__(op, kw)
+    res = composite_order(op, args)
+    if op == :quantile
+      res.map { |r| AxisGroup.__finish_reduction__(self, op, kw, r) }
+    else
+      AxisGroup.__finish_reduction__(self, op, kw, res)
+    end
   end
 
   # Per-group order statistic over the composite grouping. A flat grouping (no
@@ -655,15 +880,15 @@ class CAGroupIterator
       return nout == 1 ? res.reshape(*kdims) : res.map { |r| r.reshape(*kdims) }
     end
     out_shape = spec.slot_meta.map { |m| m[:kind] == :group ? m[:k] : m[:len] }
-    outs = Array.new(nout) { CArray.float64(*out_shape) }
+    outs = nil
     each_band_block(ccat, gslots, bslots, gaxes) do |_vi, out_idx, _co, gi|
-      result = gi.public_send(op, *args)
-      if nout == 1
-        outs[0][*out_idx] = result.reshape(*kdims)
-      else
-        result.each_with_index { |r, q| outs[q][*out_idx] = r.reshape(*kdims) }
-      end
+      results = gi.public_send(op, *args)
+      results = [results] unless results.is_a?(Array)    # quantile answers five
+      # each output takes the kind the categorical answered in
+      outs ||= results.map { |r| blank_of(r, out_shape) }
+      results.each_with_index { |r, q| outs[q][*out_idx] = r.reshape(*kdims) }
     end
+    outs ||= Array.new(nout) { blank_of(value, out_shape) }
     nout == 1 ? outs[0] : outs
   end