carray 3.0.1 → 3.0.3

data/lib/carray/methods/join.rb

@@ -66,7 +66,7 @@ class CArray
       t = transpose(*order)
     end
     inner = t.shape[-1]
-    outer_n = t.elements / inner  # 1 when ndim == 1
+    outer_n = t.shape[0...-1].inject(1, :*)  # 1 when ndim == 1
     flat = t.reshape(outer_n, inner)
 
     strings = Array.new(outer_n) { |i| flat[i, nil].to_a.join(sep_str) }

data/lib/carray/methods/locate_addr.rb

@@ -1,52 +1,266 @@
+require "carray/methods/is_in"   # fixlen_widened_with, values_in_face, values_for_lookup
+
 class CArray
 
-  # User-facing YARD docs for #locate_addr and #locate_nearest_addr live
-  # in yard-stubs/carray_order.rb (grouped with the search family).
+  # @!group Sorting and searching
 
+  # @overload locate_addr(ref)
+  #   Returns, for each element of `self`, the flat address into `ref`
+  #   where the value first occurs, or `UNDEF` where it is not present.
+  #   Builds a value-to-first-address map from `ref` in one pass (an
+  #   open-addressing hash, the same substrate as {#unique} /
+  #   {#value_counts}), then probes each element of `self`; no sort,
+  #   peak memory `O(distinct ref values)`.
+  #
+  #   The return is `ref`'s flat address (0 to `ref.elements - 1`), so a
+  #   multi-dimensional `ref` still yields a `self`-shaped result of flat
+  #   addresses; downstream reads (`ref[addr]`, `model_var[addr]`, ...)
+  #   apply it as a flat gather.
+  #
+  #   Works on numeric, `CA_OBJECT`, and `CA_FIXLEN` values, matching the
+  #   value-hash discovery family: numeric follows `==` with all NaN
+  #   collapsed to one value and `-0.0 == +0.0`; object follows Ruby
+  #   `hash` / `eql?` with Float NaN collapsed; fixlen follows byte
+  #   equality. When `ref` holds duplicate values the returned address is
+  #   the earliest (appearance-order) occurrence. Masked cells of `ref` do
+  #   not enter the map but still occupy their flat address; masked cells
+  #   of `self` are `UNDEF` in the result.
+  #
+  #   `self` and `ref` are compared at their common type, negotiated by
+  #   `CArray.result_type` — a fractional query against an integer `ref`
+  #   is compared at the promoted type rather than truncated, so `1.5` no
+  #   longer matches `1`, and integers of mixed sign are matched by value
+  #   (`-1` never matches `255`). Cross-family input (numeric against
+  #   fixlen) raises.
+  #
+  #   A time key (`CATime`) reads values that are not time arrays -- Time,
+  #   Date or String objects, in an Array, an `:object` array or a string
+  #   array -- as instants, on either side of the lookup, as {#is_in} does.
+  #
+  #   Typical use is time-axis lookup: compute the address once against a
+  #   reference axis, then reuse it to gather from many `ref`-shaped
+  #   variables without repeating the lookup.
+  #
+  #   @param ref [CArray, Array, Range] reference values to match against;
+  #     any shape (used as flat). An Array or Range is coerced with `to_ca`
+  #     and so lands in `:object`, where numeric matching follows Ruby
+  #     `eql?` (`2.0` does not match `2`); pass a CArray to match in a
+  #     numeric lane.
+  #   @return [CArray] `:int64` flat addresses into `ref`, same shape as
+  #     `self`; unmatched cells are masked.
+  #   @raise [CArray::DataTypeError] when `self` and `ref` have no common data type.
   def locate_addr (ref)
+    # A time key (any Face that reconciles operands) against values that do
+    # not -- Time, Date or String objects, a string column -- reads them as
+    # values of its kind, whichever side they are on.
+    if ref.is_a?(CArray) && ref.class == self.class &&
+       respond_to?(:in_common_unit_with) && ref.unit != unit
+      a, b = in_common_unit_with(ref)
+      return a.locate_addr(b)
+    end
+    if respond_to?(:to_comparable) && !ref.respond_to?(:to_comparable)
+      ref = values_in_face(self, ref)
+      return CArray.int64(*shape).fill(UNDEF) unless ref
+    elsif ref.respond_to?(:to_comparable) && !respond_to?(:to_comparable)
+      q = values_in_face(ref, self)
+      return CArray.int64(*shape).fill(UNDEF) unless q
+      return q.locate_addr(ref)
+    end
+    unless ref.is_a?(CArray) || ref.respond_to?(:to_ca)
+      raise TypeError, "locate_addr: the reference is an array of values (got #{ref.class})"
+    end
     ref = ref.to_ca unless ref.is_a?(CArray)
+    ref = values_for_lookup(ref)
+    if data_type == CA_FIXLEN && ref.data_type == CA_FIXLEN && bytes != ref.bytes
+      a, b = fixlen_widened_with(ref)
+      return a.locate_addr(b) unless a.equal?(self) && b.equal?(ref)
+    end
     # Put self and ref in a common lane via the single-source promotion rule
     # (CArray.result_type), so a fractional query against an int ref is compared
     # at the promoted type instead of truncating (1.5 no longer matches 1).
     # to_type is elementwise and order-preserving, so the addresses stay valid
-    # indices into ref. result_type raises for cross-family input.
-    t = CArray.result_type(self, ref)
+    # indices into ref. result_type raises for cross-family input; an integer
+    # pair of mixed sign is matched by value (see value_match_type).
+    t = value_match_type(CArray.result_type(self, ref), ref.data_type)
     q = (data_type     == t) ? self : to_type(t)
     r = (ref.data_type == t) ? ref  : ref.to_type(t)
     q.send(:__locate_addr__, r)
   end
 
+  # @overload locate_nearest_addr(ref, direction: :round, tolerance: nil)
+  #   Returns, for each element of `self`, the flat address into `ref` of
+  #   the nearest reference value. Continuous sibling of {#locate_addr}:
+  #   each cell is placed among the sorted reference values by comparing
+  #   it with them, so an integer key is exact at any size and an infinite
+  #   one keeps its place.  `:round` takes the nearer neighbour, the upper
+  #   one on a tie.
+  #
+  #   Outside `ref`'s span the direction still decides: `:floor` matches
+  #   a cell after the last value to that last value, `:ceil` matches a
+  #   cell before the first value to that first value, and `:round`
+  #   matches either to the nearer end.  The other side has no match
+  #   (`:floor` before the first value, `:ceil` after the last) and is
+  #   masked.  Use `tolerance:` to refuse matches that are too far away.
+  #
+  #   `tolerance:` (default `nil`) sets a maximum accepted absolute
+  #   distance between `self[i]` and its matched `ref` value. When
+  #   `|ref[addr] - self[i]| > tolerance`, the result cell is masked. Use
+  #   for accuracy-controlled matching (e.g. "an observation snaps to a
+  #   time step only if within N seconds").
+  #
+  #   `ref` need not be given in ascending order: it is sorted internally
+  #   and the returned addresses are mapped back to positions in `ref` as
+  #   passed.  A masked or NaN `ref` value matches nothing.  Two time keys
+  #   of different units are compared in the finer of the two.
+  #   With one value present in `ref`, that value is the match for
+  #   every cell the direction allows (`:floor` at or after it, `:ceil`
+  #   at or before it, `:round` all).  With none, every cell is masked;
+  #   an empty `self` gives an empty result.  A masked or NaN cell of
+  #   `self` is always masked.
+  #
+  #   @param ref [CArray] 1-D reference grid to match against.
+  #   @param direction [Symbol] `:round`, `:floor`, or `:ceil` — rounding
+  #     applied to the fractional position.
+  #   @param tolerance [Numeric, String, CATimedelta::Element, nil] maximum
+  #     accepted `|self - ref|` distance; cells beyond this are masked.
+  #     For a time key it is a duration: a String such as `"10 minutes"` or
+  #     a CATimedelta value (a bare number is refused, since its length
+  #     would depend on the key's unit). `nil` disables the check.
+  #   @return [CArray] `:int64` flat addresses into `ref`, same shape as
+  #     `self`; cells with no match in the direction and beyond-tolerance
+  #     cells are masked.
+  #   @raise [ArgumentError] when `direction` is not one of the accepted
+  #     symbols, or `tolerance` is not a duration for a time key.
   def locate_nearest_addr (ref, direction: :round, tolerance: nil)
     unless [:round, :floor, :ceil].include?(direction)
       raise ArgumentError,
             "locate_nearest_addr: direction must be :round / :floor / " \
             ":ceil (got #{direction.inspect})"
     end
+    return CArray.int64(*shape) if elements == 0
+    # A masked reference value matches nothing, as in locate_addr: sorting
+    # puts the masked ones last, and only the others are searched.  A NaN
+    # one has no place among the others either; it sorts after them.
     ri = ref.sort_addr
+    ri = ri[0...ref.count_not_masked] if ref.has_mask?
+    if ref.float? && ri.elements > 0
+      ri = ri[0...(ri.elements - ref[ri].is_nan.count(true))]
+    end
+    if ri.elements == 0
+      out = CArray.int64(*shape)
+      out[] = UNDEF
+      return out
+    end
     rs = ref[ri]
-    sec = rs.linear_section(self)
-    unless sec.is_a?(CArray)
-      # A single-element (scalar-like) self makes linear_section collapse to
-      # its scalar-query path, which returns a bare Float (or nil when out of
-      # range) instead of a CArray.  Rebuild a self-shaped float64 CArray so
-      # the mask_invalid -> direction -> project pipeline stays array-valued
-      # and the returned addr array matches self's shape.
-      fill = CArray.float64(*shape)
-      fill[] = sec.nil? ? UNDEF : sec
-      sec = fill
-    end
-    masked = sec.mask_invalid
+    n = rs.elements
+    rk, qk = nearest_keys(rs, self)
+    # The position of each cell among the sorted references is counted, not
+    # interpolated: :floor takes the last reference at or below it, :ceil the
+    # first at or above it.
+    # Counting keeps an integer key exact past 2**53 and an infinite one in
+    # its place, where an interpolated position would not.
     si = case direction
-         when :round then masked.round
-         when :floor then masked.floor
-         when :ceil  then masked.ceil
-         end.int64
+         when :floor then nearest_count_below(rk, qk, true) - 1
+         when :ceil  then nearest_count_below(rk, qk, false)
+         when :round then nearest_round(rk, qk, nearest_count_below(rk, qk, false))
+         end
+    si[si.lt(0) | si.ge(n)] = UNDEF
+    si[qk.is_nan.strip_mask(false)] = UNDEF if qk.float?
+    si = si.reshape(*shape)
+    si[is_masked] = UNDEF if has_mask?
     idx = ri.project(si)
     if tolerance
       dist = (ref.project(idx) - self).abs
-      idx[dist > tolerance] = UNDEF
+      idx[dist > nearest_tolerance(tolerance, dist)] = UNDEF
     end
     idx
   end
 
+  # The keys locate_nearest_addr orders by: the storage of the sorted
+  # reference and of the query, in one numeric type.  A Face key is first
+  # brought into the reference's space (two time keys of different units
+  # into the finer of the two, which holds both exactly); plain keys meet at
+  # the type CArray.result_type gives, an integer pair of mixed sign at one
+  # that holds both.
+  private def nearest_keys(rs, q)
+    if rs.face? || q.face?
+      if rs.respond_to?(:to_unit) && q.class == rs.class && q.unit != rs.unit
+        u  = CATimeUnitAlgebra.finer(rs.unit, q.unit)
+        rs = rs.to_unit(u)
+        q  = q.to_unit(u)
+      end
+      q  = rs.__send__(:__reconcile_operand__, q, "locate_nearest_addr")
+      rs = rs.__send__(:__face_storage__)
+    end
+    t = value_match_type(CArray.result_type(q, rs), rs.data_type)
+    rk = (rs.data_type == t) ? rs : rs.to_type(t)
+    qk = (q.data_type  == t) ? q  : q.to_type(t)
+    [rk, qk.flatten]
+  end
+
+  # For each query key, how many of the sorted reference keys are below it
+  # (inclusive: at or below).  A numeric key is binary-searched in C; an
+  # object key is sorted together with the references, a tie putting the
+  # reference first when it counts, and counted against the references met
+  # before it.
+  private def nearest_count_below(rk, qk, inclusive)
+    return rk.send(:__count_below__, qk, inclusive) unless rk.data_type == CA_OBJECT
+    n, m = rk.elements, qk.elements
+    keys = CArray.concatenate([rk, qk])
+    tag  = CArray.int8(n + m)
+    tag[0...n]   = inclusive ? 0 : 1
+    tag[n...n+m] = inclusive ? 1 : 0
+    perm  = CArray.sort_addr(keys, tag)
+    seen  = perm.lt(n).cumsum.int64
+    query = perm.ge(n)
+    count = CArray.int64(m)
+    count[perm[query] - n] = seen[query]
+    count
+  end
+
+  # :round -- an exact match takes its first reference; otherwise the
+  # nearer of the two neighbours, the upper one on a tie.  +lt+ counts the
+  # references below each key, so the upper neighbour is at lt and an exact
+  # match is the reference there.
+  private def nearest_round(rk, qk, lt)
+    lo = rk.project(lt - 1)
+    hi = rk.project(lt)
+    upper = (hi - qk).le(qk - lo).strip_mask(false)
+    upper[lo.is_masked] = true if lo.has_mask?
+    upper[hi.is_masked] = false if hi.has_mask?
+    upper[hi.eq(qk).strip_mask(false)] = true
+    si = lt - 1
+    si[upper] = lt[upper]
+    si
+  end
+
+  # The tolerance in the units of the distance. A time key measures its
+  # distance as a CATimedelta, so its tolerance is a duration: a String in
+  # the spelling CArray.time takes for a unit ("10 minutes"), or a
+  # CATimedelta value. A bare number would mean a different length in each
+  # unit, so it is refused there; any other key takes a number.
+  private def nearest_tolerance(tolerance, dist)
+    unless dist.is_a?(CATimedelta)
+      if tolerance.is_a?(String)
+        raise ArgumentError,
+              "tolerance: #{tolerance.inspect} is a duration, but the key is " \
+              "#{data_type_name}; give a number"
+      end
+      return tolerance
+    end
+    case tolerance
+    when String
+      res = CATime::Resolution.parse(tolerance)
+      CATimedelta::Element.new(res.count, res.base)
+    when CATimedelta::Element
+      tolerance
+    else
+      raise ArgumentError,
+            "tolerance: a time key needs a duration such as \"10 minutes\" " \
+            "or a CATimedelta value (got #{tolerance.inspect})"
+    end
+  end
+
+  # @!endgroup
+
 end

data/lib/carray/methods/mask_duplicates.rb

@@ -1,3 +1,5 @@
+require "carray/methods/discovery_along"
+
 class CArray
 
   # @overload mask_duplicates(axis: nil)
@@ -23,7 +25,39 @@ class CArray
   #     `nil` uses flatten order.
   #   @return [CArray] shape-preserving copy of `self` with
   #     duplicates masked.
-  def mask_duplicates (axis: nil)
+  # @overload mask_duplicates(along: k)
+  #   Returns a shape-preserving copy of `self` with every cell of a
+  #   duplicated **sub-array** masked, comparing whole sub-arrays rather
+  #   than cells: `along: k` names the axis whose index enumerates them,
+  #   so `z.mask_duplicates(along: 0)` masks each repeated row of a 2-D
+  #   array and keeps the first occurrence.
+  #
+  #   Note the contrast with `axis:`, which names the axis a *fiber runs
+  #   along* and marks repeated values inside each fiber. The two cannot
+  #   be given together.
+  #
+  #   A sub-array holding a masked cell does not participate: it is
+  #   neither judged a duplicate nor able to make a later one, and its
+  #   cells keep the mask they came with. `object` arrays are refused,
+  #   because their cells hold Ruby references.
+  #
+  #   @param along [Integer] axis whose index enumerates the sub-arrays.
+  #   @return [CArray] shape-preserving copy of `self` with duplicated
+  #     sub-arrays masked.
+  def mask_duplicates (axis: nil, along: nil)
+    reject_axis_with_along(axis, along, "mask_duplicates")
+    if along
+      keys = fibers_as_cells(along, "mask_duplicates")
+      #  A sub-array that did not participate (it held a masked cell) is
+      #  masked in `keys` already; only the ones that did and repeated
+      #  are duplicates here.
+      repeated = keys.mask_duplicates.is_masked & keys.is_not_masked
+      args = [:_] * ndim
+      args[normalize_axis(along, "mask_duplicates")] = nil
+      spread = CArray.boolean(*shape)
+      spread[] = repeated[*args]
+      return mask_where(spread)
+    end
     dup =
       if axis.nil?
         # One seen-set over the flattened array, then restore shape.

data/lib/carray/methods/mode.rb

@@ -65,12 +65,25 @@ class CArray
   #   Only meaningful for discrete / binned data: raw float is almost all
   #   unique, so every value is modal and the per-axis Array grows to the
   #   fiber length. Bin first. Same NaN / mask semantics as {#is_mode}.
+  #   A complex array raises {CArray::DataTypeError}, since the modes
+  #   are listed in ascending order; {#is_mode} marks its modal cells.
   #
   #   @param axis [Integer, nil] axis to take the mode along; `nil` uses
   #     the whole array.
   #   @return [CArray, Array<CArray>] 1-D CArray (flat) or an Array of
   #     reduced CArrays, one per mode rank (per-axis).
   def mode (axis: nil)
+    # An error from the methods mode is made of (sort, ...) names mode.
+    CArray.__answer_as__(:mode) { mode_answered(axis) }
+  end
+
+  private def mode_answered (axis)
+    if complex?
+      raise CArray::DataTypeError,
+            "mode: the modes are listed in ascending order, and a " \
+            "#{data_type_name} value has no order (complex numbers are not " \
+            "ordered); is_mode marks the cells that hold a mode"
+    end
     return __mode_flat if axis.nil?
     k = normalize_axis(axis, "mode")
 
@@ -120,7 +133,11 @@ class CArray
   def __mode_flat
     values, counts = value_counts
     return values if values.elements == 0
-    values[counts.eq(counts.max)].sort
+    modes = values[counts.eq(counts.max)]
+    # Records are sorted only by the members their struct declares in
+    # order_by:; without one the modes stay in first-appearance order.
+    return modes if is_a?(CARecord) && data_class.order_by.nil?
+    modes.sort
   end
 
 end

data/lib/carray/methods/nunique.rb

@@ -1,3 +1,5 @@
+require "carray/methods/discovery_along"
+
 class CArray
 
   # @overload nunique(axis: nil, keep_axis: false)
@@ -29,7 +31,26 @@ class CArray
   #     axis as a length-1 axis instead of dropping it.
   #   @return [Integer, CArray] Integer for `axis: nil`, otherwise a
   #     reduced `CA_INT64` CArray.
-  def nunique (axis: nil, keep_axis: false)
+  # @overload nunique(along: k)
+  #   Returns how many distinct **sub-arrays** `self` holds, comparing
+  #   whole sub-arrays rather than cells: `along: k` names the axis
+  #   whose index enumerates them, so `z.nunique(along: 0)` counts the
+  #   distinct rows of a 2-D array. This is `len(np.unique(z, axis=k))`.
+  #
+  #   Note the contrast with `axis:`, which names the axis a *fiber runs
+  #   along* and counts the distinct values inside each fiber -- one
+  #   count per fiber, not one count for the array. The two cannot be
+  #   given together.
+  #
+  #   Sub-arrays holding a masked cell do not participate and are not
+  #   counted. `object` arrays are refused, because their cells hold
+  #   Ruby references.
+  #
+  #   @param along [Integer] axis whose index enumerates the sub-arrays.
+  #   @return [Integer] the number of distinct sub-arrays.
+  def nunique (axis: nil, keep_axis: false, along: nil)
+    reject_axis_with_along(axis, along, "nunique")
+    return fibers_as_cells(along, "nunique").nunique if along
     # Per-fiber single-pass seen-set hash (C __nunique__), one lane per data type
     # family (numeric widen / NaN collapse, object rb_hash + rb_eql, fixlen
     # byte-hash + memcmp). Masked cells are skipped; the accumulator is a no-op

data/lib/carray/methods/repeat.rb

@@ -0,0 +1,91 @@
+class CArray
+
+  # @overload repeat(count, axis: nil)
+  #   @overload repeat(counts, axis: nil)
+  #   Returns each element (or each sub-array) of `self` laid down
+  #   `count` times in place, one after another.
+  #
+  #   With an Integer, every element is repeated the same number of
+  #   times. With an array of counts -- one per element, or one per
+  #   sub-array when `axis:` is given -- each is repeated its own number
+  #   of times, and a count of 0 drops that one:
+  #
+  #     v = CA_INT([10, 20, 30])
+  #     v.repeat(2)              #  => [ 10, 10, 20, 20, 30, 30 ]
+  #     v.repeat([3, 1, 2])      #  => [ 10, 10, 10, 20, 30, 30 ]
+  #     v.repeat([2, 0, 1])      #  => [ 10, 10, 30 ]
+  #
+  #   This is `np.repeat`, and it is not {#tile}: `repeat` puts the
+  #   copies of one element next to each other, `tile` lays the whole
+  #   array down again -- `v.tile(2)` is `[10, 20, 30, 10, 20, 30]`.
+  #
+  #   `axis: k` repeats the sub-arrays enumerated by axis `k` rather
+  #   than the cells, so a 2-D array repeats whole rows and the result
+  #   keeps its shape apart from that axis:
+  #
+  #     t = CA_INT([[0, 1], [2, 3], [4, 5]])
+  #     t.repeat([2, 1, 1], axis: 0)
+  #     #  => [ [ 0, 1 ],
+  #     #       [ 0, 1 ],
+  #     #       [ 2, 3 ],
+  #     #       [ 4, 5 ] ]
+  #
+  #   Without `axis:` a multi-dimensional receiver is taken in flatten
+  #   (row-major) order and the result is 1-D, as `np.repeat` does.
+  #
+  #   The result is a **view** of `self` -- the same element named as
+  #   many times as it was repeated -- so nothing is copied and writing
+  #   through it reaches `self`, at every position that names the cell
+  #   written. Take a `copy` when that is not wanted.
+  #
+  #   Counts must be non-negative, and there must be exactly as many as
+  #   there are elements (or sub-arrays along `axis:`). A masked count
+  #   is refused: it names no number of repetitions.
+  #
+  #   @param count [Integer, CArray, Array] how many times to repeat --
+  #     one number for all, or one per element / sub-array.
+  #   @param axis [Integer, nil] axis whose index enumerates the
+  #     sub-arrays to repeat; `nil` repeats cells in flatten order.
+  #   @return [CArray] the repeated elements, as a view of `self`.
+  def repeat (count, axis: nil)
+    along = axis.nil? ? nil : normalize_axis(axis, "repeat")
+    width = along ? shape[along] : elements
+
+    counts =
+      case count
+      when Integer
+        if count < 0
+          raise ArgumentError, "repeat: count must not be negative (got #{count})"
+        end
+        CArray.int64(width).fill(count)
+      else
+        given = count.to_ca.int64
+        unless given.elements == width
+          raise ArgumentError,
+                "repeat: #{given.elements} counts for #{width} " \
+                "#{along ? "sub-arrays along axis #{along}" : 'elements'}"
+        end
+        if given.has_mask? and given.count_masked > 0
+          raise ArgumentError,
+                "repeat: a masked count names no number of repetitions"
+        end
+        if given.lt(0).any
+          raise ArgumentError, "repeat: counts must not be negative"
+        end
+        given.flatten
+      end
+
+    source = along ? self : (ndim > 1 ? flatten : self)
+    source[*gather_args(CArray.segment_index(lengths: counts), along)]
+  end
+
+  #  One index argument per axis: the gathered index on the axis being
+  #  repeated, whole axes everywhere else.
+  private def gather_args (index, along)
+    return [index] unless along
+    args = [nil] * ndim
+    args[along] = index
+    args
+  end
+
+end

data/lib/carray/methods/resize.rb

@@ -4,8 +4,8 @@ class CArray
   #   Returns `self` resized to `newdim`. The original data is
   #   placed at offset 0 (positive size) or right-aligned (negative
   #   size); the new area outside the original region is filled
-  #   with `fill_value`, or -- for fixlen storage -- left as zero
-  #   bytes. Pass `UNDEF` to mask the new area.
+  #   with `fill_value`, or left as zero storage when it is not given
+  #   (0 for a numeric array). Pass `UNDEF` to mask the new area.
   #
   #   Each entry of `newdim` is: `nil` to keep the current
   #   `shape[i]`, a positive Integer for a new size with the
@@ -13,15 +13,19 @@ class CArray
   #   `d` for a new size `|d|` with the original right-aligned.
   #
   #   Works on Face arrays (CARecord / CATime / ...) and
-  #   plain fixlen: the resize is done on the storage layout
-  #   (preserving bytes) and re-wrapped as the same Face.
+  #   plain fixlen: the result is the same Face, and `fill_value` is a
+  #   value of it (a Time for a time array).
   #
   #   @param newdim [Array<Integer, nil>] new shape spec, one entry
   #     per axis.
-  #   @param fill_value [Object] value for the extended area.
+  #   @param fill_value [Object] value for the extended area (zero
+  #     storage when not given).
   #   @return [CArray] resized copy.
-  def resize (*newdim, fill_value: 0)
-    raise "ndim mismatch" if newdim.size != ndim
+  NO_FILL_VALUE = ::Object.new.freeze
+  private_constant :NO_FILL_VALUE
+
+  def resize (*newdim, fill_value: NO_FILL_VALUE)
+    raise ArgumentError, "ndim mismatch" if newdim.size != ndim
     offset = Array.new(ndim, 0)
     newdim = newdim.each_with_index.map do |d, i|
       case d
@@ -32,24 +36,18 @@ class CArray
         offset[i] = size - shape[i] if d < 0
         size
       else
-        raise "invalid dimension size"
+        raise ArgumentError, "invalid dimension size"
       end
     end
-    face_parent = self.face? ? self : nil
-    src = self
-    src = src.parent while src.face?
-    dt    = src.data_type
-    bytes = (dt == :fixlen) ? src.bytes : nil
-    out = CArray.new(dt, newdim, bytes: bytes)
-    # Fill the new area: numeric storage takes fill_value as-is; fixlen
-    # storage cannot hold a numeric 0, so leave zero bytes and honor only
-    # UNDEF (mask) or an explicit String fill.
-    if dt != :fixlen || fill_value.equal?(UNDEF) || fill_value.is_a?(String)
-      out[] = fill_value
-    end
-    out.mask.paste(offset, src.false) if out.has_mask?
-    out.paste(offset, src)
-    out = out.face_lift(face_parent) if face_parent
+    # The original cells are copied as storage, so a read-only Face (a
+    # const string, a categorical) resizes too.  The new area starts as zero
+    # storage; a given fill_value is written as a value of the array, which a
+    # read-only Face refuses.
+    out = __blank_like__(newdim)
+    out_storage = out.__send__(:__face_storage__)
+    out[] = fill_value unless fill_value.equal?(NO_FILL_VALUE)
+    out_storage.mask.paste(offset, self.false) if out_storage.has_mask?
+    out_storage.paste(offset, __face_storage__)
     out
   end