carray 3.0.6 → 3.0.7

data/lib/carray/basics.rb

@@ -162,6 +162,10 @@ class CArray
     lfill = fill_value if lfill.nil?
     ufill = fill_value if ufill.nil?
     out = copy
+    # Whatever is written must fit: a finer time, a wider fixed string.
+    [min, max, lfill, ufill].each { |v|
+      out, = branches_in_common(out, v) unless v.nil? || UNDEF.equal?(v)
+    }
     out[self < min] = lfill.nil? ? min : lfill unless min.nil?
     out[self > max] = ufill.nil? ? max : ufill unless max.nil?
     out
@@ -170,6 +174,12 @@ class CArray
   # An array of +shape+ of the same kind as self: its data type and cell
   # width, or its Face over a zero storage.  Nothing is written into it, so
   # it can be built for a read-only Face too.
+  # Whether a cell can be given a value it has not seen.  Not a CAConstString,
+  # whose strings share a buffer, or a CACategorical, whose codes index a
+  # vocabulary.  A view that is read-only can still hold them: it is only
+  # that view that cannot be written.
+  private def holds_new_values? = true
+
   private def blank_like (shape)
     storage = face_storage
     out = CArray.new(storage.data_type, shape, bytes: storage.bytes)
@@ -334,7 +344,8 @@ class CArray
   #   masked: a missing bound is not read as either, so fill it first.
   #
   #   Boundary is strict `[min, max]`: values equal to a bound
-  #   remain unchanged in both the clamped and filled variants.
+  #   remain unchanged in both the clamped and filled variants.  A NaN
+  #   is in neither range and stays NaN.
   #
   #   @param min [Numeric, nil] lower bound; `nil` for one-sided
   #     clip above.
@@ -597,14 +608,14 @@ class CArray
   # reductions do: each block value is written into a blank of the Face
   # (which reads a CATime::Element, a string, a Face array ...) and handed
   # to the slab engine as the storage it became; the result is lifted back
-  # at the end.  A read-only Face has no blank to write into, so its values
-  # are collected as the surface objects they are.  A `data_type:` from the
-  # caller is the caller's, and passes through.
+  # at the end.  A Face that holds no new value has no blank to write into,
+  # so its values are collected as the surface objects they are.  A
+  # `data_type:` from the caller is the caller's, and passes through.
   module FaceSlabResult
     def map_slab (**kw, &block)
       return super unless face? && kw[:data_type].nil? && block
-      return super(**kw, data_type: :object, &block) if read_only?
-      out = super(**kw, data_type: face_storage.data_type) { |slab|
+      return super(**kw, data_type: :object, &block) unless holds_new_values?
+      out = super(**kw, **face_slab_type) { |slab|
         face_slab_storage(block.call(slab), slab.shape)
       }
       out.face_lift(self)
@@ -612,10 +623,10 @@ class CArray
 
     def reduce_slab (**kw, &block)
       return super unless face? && kw[:data_type].nil? && block
-      return super(**kw, data_type: :object, &block) if read_only?
+      return super(**kw, data_type: :object, &block) unless holds_new_values?
       fiber = kw.key?(:init)
       init  = kw.delete(:init)
-      out = super(**kw, data_type: face_storage.data_type) { |slab|
+      out = super(**kw, **face_slab_type) { |slab|
         value = if fiber
                   slab.to_a.flatten.inject(init) { |acc, e| block.call(acc, e) }
                 else
@@ -628,6 +639,13 @@ class CArray
 
     private
 
+    # The engine's output type.  Fixlen storage is named by leaving it out: the
+    # name alone has no width, and the source's is the one wanted.
+    def face_slab_type
+      storage = face_storage
+      storage.data_type == CA_FIXLEN ? {} : { data_type: storage.data_type }
+    end
+
     def face_slab_storage (value, shape)
       cell = blank_like(shape)
       cell[] = value

data/lib/carray/bincount_nd.rb

@@ -238,7 +238,10 @@ class CArray
       ext_sizes   = @lengths.map { |l| l + 1 }      # +1: upper overflow cell
       strides_ext = ext_sizes.each_with_index.map { |_, k| ext_sizes[(k + 1)..].inject(1, :*) }
       total_ext   = ext_sizes.inject(:*)
-      widen       = total_ext > 0x7fffffff          # int64 flat for big joint tables
+      # The flat index is worked out in the labels' own type, so it must reach
+      # the last cell of the table in that type.
+      label_bits  = 8 * chunk.bytes - (chunk.data_type_name.start_with?("u") ? 0 : 1)
+      widen       = total_ext - 1 >= 2 ** label_bits
 
       # canonical [fiber..., sample, channel] view (channel last); weights to
       # [fiber..., sample].  Skip the transpose when the layout is already
@@ -270,7 +273,10 @@ class CArray
         ravel = nil
         (0...@m).each do |k|
           b = tchunk[nil, k]
-          b = b.clip(0, @lengths[k]) if b.max > @lengths[k] - 1
+          top = b.max
+          # No present cell in a channel: every sample is dropped.
+          return self if top == UNDEF
+          b = b.clip(0, @lengths[k]) if top > @lengths[k] - 1
           b = b.int64 if widen
           term = strides_ext[k] == 1 ? b : b * strides_ext[k]
           ravel = ravel.nil? ? term : ravel + term

data/lib/carray/block_iterator.rb

@@ -88,10 +88,15 @@ class CABlockIterator < CAIterator
     @sizes   = Array.new(@sndim)
     blocks.each_with_index do |b, i|
       if b.is_a?(Range)
+        unless b.begin.is_a?(Integer) && b.end.is_a?(Integer)
+          raise TypeError, "blocks: axis #{i} takes a Range of Integer positions, got #{b.inspect}"
+        end
         offsets[i] = b.begin
         @sizes[i]  = b.end - b.begin + (b.exclude_end? ? 0 : 1)
+      elsif b.is_a?(Integer)
+        @sizes[i]  = b
       else
-        @sizes[i]  = Integer(b)
+        raise TypeError, "blocks: a tile size must be an Integer (got #{b.class})"
       end
       if @sizes[i] < 1
         raise ArgumentError, "blocks: tile size on axis #{i} must be >= 1"
@@ -365,16 +370,9 @@ class CABlockIterator < CAIterator
   def count (*args, **kw)
     return count_not_masked(**kw) if args.empty?
     kw = CAIterator.reduce_keywords(:count, kw)
-    out = nil
-    each_region do |strip_ranges, tiles, out_ranges|
-      view = @source[*strip_ranges].block_view(*tiles)
-      # block_view is a CAStride, so #count is not shadowed; dispatch
-      # CArray#count explicitly anyway, matching the family regularity.
-      red = CArray.instance_method(:count).bind_call(view, *args, axis: @tile_axes, **kw)
-      out ||= CArray.new(red.data_type, @shape, bytes: red.bytes)
-      out[*out_ranges] = red
-    end
-    out
+    # block_view is a CAStride, so #count is not shadowed; dispatch
+    # CArray#count explicitly anyway, matching the family regularity.
+    assemble { |view, _| count_cells(view, *args, axis: @tile_axes, **kw) }
   end
 
   # @overload count_not_masked
@@ -477,6 +475,12 @@ class CABlockIterator < CAIterator
       return src[addr.strip_mask(hole[0])].copy
     end
     out = src[addr.strip_mask(0)].copy
+    unless out.__send__(:holds_new_values?)
+      # A const string's cells are written as Strings and packed again.
+      text = out.to_string
+      text[empty] = fill_value.nil? ? UNDEF : fill_value
+      return text.to_const_string
+    end
     out[empty] = fill_value.nil? ? UNDEF : fill_value
     out
   end
@@ -681,15 +685,24 @@ class CABlockIterator < CAIterator
   #   into a source-shaped CArray (the out-of-bounds cells of a partial edge
   #   tile are dropped).  Well-defined because tiles do not overlap; the source
   #   is not modified (a new array is returned).  Without a block, an Enumerator.
+  #   The result has the source's data type; a Face source gives a result of
+  #   the same Face, and a read-only Face (a categorical, a const string) an
+  #   object array of its surface values.
   #   @yieldparam tile [CArray]
   #   @return [CArray, Enumerator] source-shaped
   def map
     return to_enum(:map) unless block_given?
-    pout = CArray.new(padded_source.data_type, padded_source.shape, bytes: padded_source.bytes)
+    src  = padded_source
+    surface = src.face? && !src.__send__(:holds_new_values?)
+    pout = surface ? CArray.new(CA_OBJECT, src.shape) : src.__send__(:blank_like, src.shape)
     pgv  = pout.block_view(*@sizes)
     tgv  = tile_grid_view
     nils = Array.new(@sndim, nil)
-    CArray.each_index(*@shape) { |*g| pgv[*g, *nils] = yield(tgv[*g, *nils]) }
+    CArray.each_index(*@shape) { |*g|
+      tile = yield(tgv[*g, *nils])
+      tile = tile.to_a if surface && tile.is_a?(CArray) && tile.face?
+      pgv[*g, *nils] = tile
+    }
     pout[*@sndim.times.map { |i| 0...@source.shape[i] }].copy
   end
 
@@ -797,20 +810,23 @@ class CABlockIterator < CAIterator
       tile    = tgv[*g, *nils]
       scanned = tile.copy.reshape(tile.elements).public_send(op, *args).reshape(*@sizes)
       unless pout
-        pout = CArray.new(scanned.data_type, padded_source.shape, bytes: scanned.bytes)
+        pout = scanned.face? ? scanned.__send__(:blank_like, padded_source.shape) :
+                 CArray.new(scanned.data_type, padded_source.shape, bytes: scanned.bytes)
         pout[] = UNDEF
         pgv  = pout.block_view(*@sizes)
       end
       pgv[*g, *nils] = scanned
     end
+    # a source with no cells has no tile; its own scan gives the type
+    return @source.copy.reshape(@source.elements).public_send(op, *args).reshape(*@source.shape) unless pout
     pout[*@sndim.times.map { |i| 0...@source.shape[i] }].copy
   end
 
   # A source-shaped array that can hold what #tile_wise gives: of its kind,
-  # or an object array for a read-only Face, which cannot be written cell by
-  # cell.
+  # or an object array for a Face that holds no new value, which cannot be
+  # written cell by cell.
   def tile_output (lagged)
-    if lagged.face? && lagged.read_only?
+    if lagged.face? && !lagged.__send__(:holds_new_values?)
       CArray.object(*@source.shape)
     else
       lagged.__send__(:blank_like, @source.shape)
@@ -834,10 +850,21 @@ class CABlockIterator < CAIterator
       if pshape == @source.shape.to_a
         @source
       else
-        pad = @source.__send__(:blank_like, pshape)   # a Face stays one
-        pad[] = UNDEF
-        pad[*@sndim.times.map { |i| 0...@source.shape[i] }] = @source
-        pad
+        interior = @sndim.times.map { |i| 0...@source.shape[i] }
+        if @source.face? && !@source.__send__(:holds_new_values?)
+          # A Face that holds no new value cannot be written: its storage is
+          # padded and the Face put back on.
+          storage = @source.__send__(:face_storage)
+          pad = CArray.new(storage.data_type, pshape, bytes: storage.bytes)
+          pad[] = UNDEF
+          pad[*interior] = storage
+          pad.face_lift(@source)
+        else
+          pad = @source.__send__(:blank_like, pshape)   # a Face stays one
+          pad[] = UNDEF
+          pad[*interior] = @source
+          pad
+        end
       end
     end
   end

data/lib/carray/categorical.rb

@@ -59,6 +59,8 @@ require "carray/methods/is_in"   # refuse_range_set, for the set-valued verbs
 # kernels are gated off (`cat + 1` raises; arithmetic on category codes is
 # not meaningful).
 class CACategorical < CAObject
+  private def holds_new_values? = false
+
 
   # raw-byte unpack format per storage (codes) data_type, native endian.
   # The FIXLEN surface delivers a per-cell fetch as an N-byte String; this
@@ -373,12 +375,13 @@ class CACategorical < CAObject
   #   Returns a boolean CArray marking cells whose category equals
   #   `label`. A CArray is compared cell by cell, by label: another
   #   categorical is matched whatever order its labels are in, and a
-  #   masked cell on either side gives UNDEF. Anything else, a Ruby Array
-  #   included, is one label, as for {CArray#eq}. An unknown label matches
-  #   nothing.
+  #   masked cell on either side gives UNDEF. `UNDEF` asks the mask, as for
+  #   {CArray#eq}: true where a cell is in no category. Anything else, a Ruby
+  #   Array included, is one label. An unknown label matches nothing.
   #   @param label [Object, CArray] category to match, or one per cell.
   #   @return [CArray]
   def eq(label)
+    return is_masked if label.equal?(UNDEF)
     codes.eq(codes_of(label))
   end
 
@@ -388,24 +391,31 @@ class CACategorical < CAObject
   #     cell.
   #   @return [CArray]
   def ne(label)
+    return is_not_masked if label.equal?(UNDEF)
     codes.ne(codes_of(label))
   end
 
   # @overload count(label)
   #   Returns the number of cells whose category equals `label`
-  #   (0 for an unknown label).
+  #   (0 for an unknown label). `UNDEF` counts the cells in no category,
+  #   as {#count_masked}. The keywords of {CArray#count} (`axis:`,
+  #   `keep_axis:`, `min_count:`, `fill_value:`) are taken in both forms.
   #   @param label [Object] category to count.
   #   @return [Integer]
   # @overload count
   #   Returns the number of cells in some category (not masked), as
   #   {CArray#count} with no value does.
   #   @return [Integer]
-  def count(*args)
-    return count_not_masked if args.empty?
+  def count(*args, **kw)
+    return count_not_masked(**kw) if args.empty?
     raise ArgumentError, "count: wrong number of arguments (given #{args.size}, expected 0..1)" if args.size > 1
     label = args[0]
+    return count_masked(**kw) if label.equal?(UNDEF)
     code = @labels.index(label)
-    code ? codes.count(code) : 0
+    return codes.count(code, **kw) if code
+    # an unknown label matches no cell; counted over the same mask so the
+    # keywords (axis:, min_count:, fill_value:) answer as for a known label
+    kw.empty? ? 0 : codes.ne(codes).count(true, **kw)
   end
 
   # Per-category counts as a length-k array aligned to #labels. Trailing empty
@@ -494,7 +504,10 @@ class CACategorical < CAObject
   #   @return [CArray]
   def is_in (values)
     refuse_range_set(values, "is_in")
-    wanted = label_list(values).filter_map { |l| @labels.index(l) }
+    wanted = label_list(values).filter_map do |l|
+      # nan-order: looks a label up and orders nothing; == does not find a NaN.
+      l.is_a?(Float) && l.nan? ? @labels.index { |x| x.is_a?(Float) && x.nan? } : @labels.index(l)
+    end
     codes.is_in(CArray.int64(wanted.size) { |i| wanted[i] })
   end
 

data/lib/carray/categorical_iterator.rb

@@ -492,6 +492,7 @@ class CACategoricalIterator < CASegmentIterator
   # each c) — bounded by K, typically small.  A fused per-fiber variance
   # kernel is a natural follow-on if bench demands it.
   def axis_by_masked_copy (axis, op, out_data_type = core_reduce_type(op))
+    return axis_by_core(axis, op) if @value.face?
     h = @value
     axis = checked_axis(axis, op)
     full_c    = resolve_axis_codes(@cat.codes, h.shape, axis)
@@ -534,7 +535,7 @@ class CACategoricalIterator < CASegmentIterator
       flat ? g.__send__(op, *args, axis: axis, keep_axis: true)
            : g.__send__(op, *args, axis: axis)
     end
-    if answers.first.face? && answers.first.read_only?
+    if answers.first.face? && !answers.first.__send__(:holds_new_values?)
       answers = answers.map { |a| CArray.object(*a.shape) { a.to_a } }
     end
     out = flat ? CArray.concatenate(answers) : CArray.stack(answers, axis: 0).copy

data/lib/carray/conditional.rb

@@ -130,6 +130,13 @@ class CArray
     CATriOp.__build__(self, branch.(x), branch.(y), CATriOp::OP_SELECT)
   end
 
+  # The two branches of a selection, in a form that holds the cells of both.
+  # A Face whose cells differ by more than their values (a time's unit, a
+  # fixed string's width) brings them to one here, whichever branch is which.
+  private def branches_in_common (x, y)
+    [x, y]
+  end
+
   private def face_then_else (x, y, face)
     # A Face branch decides the result: the other branch is written into a
     # copy of it through the Face's own store, so an instant stays an instant.
@@ -141,10 +148,11 @@ class CArray
       sy = y.is_a?(CAConstString) ? y.to_string : y
       return CArray.const_string(then_else(sx, sy), encoding: face.encoding)
     end
+    x, y   = face.__send__(:branches_in_common, x, y)
     x_full = x.is_a?(CArray) && !x.scalar?
     y_full = y.is_a?(CArray) && !y.scalar?
     base   = y_full ? y : x
-    if base.read_only?
+    unless base.__send__(:holds_new_values?)
       # No store to write through (a CACategorical's codes): select among
       # the values themselves.
       result = CArray.object(*shape)
@@ -180,7 +188,8 @@ class CArray
             "replace_where: cond must be a boolean CArray (data_type == CA_BOOLEAN)"
     end
     result = self.copy
-    result[cond] = b.is_a?(CArray) ? b[cond] : b
+    # A CScalar takes no index: like a number, it is the value for every cell.
+    result[cond] = b.is_a?(CArray) && !b.scalar? ? b[cond] : b
     result
   end
 
@@ -265,6 +274,8 @@ class CArray
   #   @param condlist [Array<CArray>] boolean selectors.
   #   @param choicelist [Array<CArray, Numeric, Object>] values, one
   #     per condition (same length as `condlist`).
+  #   When a choice is a Face the result is that Face (the choices meet as
+  #   in {#then_else}), and `default` is UNDEF unless it is given.
   #   @param default [CArray, Numeric, Object] value written where no
   #     condition holds.
   #   @param data_type [Symbol, Integer, nil] override for the result
@@ -278,7 +289,7 @@ class CArray
   #                   [-x,    x * 10],
   #                   default: 999)
   #     # => [5.0, 3.0, -10.0, 0.0, 10.0, 999.0]
-  def self.select (condlist, choicelist, default: 0, data_type: nil)
+  def self.select (condlist, choicelist, default: (no_default = true; 0), data_type: nil)
     unless condlist.is_a?(Array) && choicelist.is_a?(Array)
       raise ArgumentError, "select: condlist and choicelist must be Arrays"
     end
@@ -296,6 +307,14 @@ class CArray
     end
     shape = first.shape
 
+    if data_type.nil?
+      face = choicelist.find { |v| v.is_a?(CArray) && !v.scalar? && v.face? }
+      if face
+        fallback = no_default ? UNDEF : default
+        return select_among_faces(condlist, choicelist, fallback, face, shape)
+      end
+    end
+
     dt = data_type || selection_type(choicelist + [default])
     # `default` can be either a same-shape CArray (per-cell fallback) or a
     # scalar (broadcast to every cell).
@@ -317,7 +336,7 @@ class CArray
               "select: condlist[#{k}] must be a same-shape boolean CArray"
       end
       v = choicelist[k]
-      out[c] = v.is_a?(CArray) ? v[c] : v
+      out[c] = v.is_a?(CArray) && !v.scalar? ? v[c] : v
     end
     if !data_type && selection_text?(choicelist + [default])
       out = CAString.wrap(out)
@@ -331,6 +350,35 @@ class CArray
   # some type, so it leaves the type to the others.  A String or Symbol is a
   # value, which CArray.result_type would read as the name of a data type
   # ("int32"), so it makes the result object.
+  # select over Face choices.  Each condition is a then_else on the choices
+  # below it, so the Faces meet as they do there; a Face that cannot be
+  # written selects among its values.
+  def self.select_among_faces (condlist, choicelist, fallback, face, shape)
+    if face.is_a?(CAConstString)
+      choices = choicelist.map { |v| v.is_a?(CAConstString) ? v.to_string : v }
+      text    = select(condlist, choices, default: fallback)
+      return CArray.const_string(text, encoding: face.encoding)
+    end
+    unless face.__send__(:holds_new_values?)
+      choices = choicelist.map { |v| v.is_a?(CArray) && v.face? ? v.to_type(CA_OBJECT) : v }
+      return select(condlist, choices, default: fallback)
+    end
+    unless face.shape == shape
+      raise ArgumentError, "select: choicelist shape #{face.shape} differs from condlist shape #{shape}"
+    end
+    out = CArray.boolean(*shape).zero.then_else(face, fallback)
+    (condlist.size - 1).downto(0) do |k|
+      c = condlist[k]
+      unless c.is_a?(CArray) && c.boolean? && c.shape == shape
+        raise ArgumentError,
+              "select: condlist[#{k}] must be a same-shape boolean CArray"
+      end
+      out = c.then_else(choicelist[k], out)
+    end
+    out
+  end
+  private_class_method :select_among_faces
+
   def self.selection_type (values)
     typed = values.reject { |v| v.equal?(UNDEF) }
     if typed.empty? || typed.any? { |v| v.is_a?(String) || v.is_a?(Symbol) }

data/lib/carray/const_string.rb

@@ -86,6 +86,7 @@ end
 # (categorical labels) prefer {CACategorical}, which stores each distinct
 # value once.
 class CAConstString
+  private def holds_new_values? = false
 
   # Read-only String Face: L1 string operations only (no in-place Mutable).
   # Its C-native byte predicates / search / comparison (ext/ca_obj_const_string.c)
@@ -205,6 +206,17 @@ class CAConstString
     const_string_lift(to_string.clip(*args, **kw))
   end
 
+  # A String has no distance, so there is no nearest one; refused in the
+  # words CAString uses.
+  def search_nearest (*args, **kw)
+    to_string.search_nearest(*args, **kw)
+  end
+
+  # @see #search_nearest
+  def search_nearest_addr (*args, **kw)
+    to_string.search_nearest_addr(*args, **kw)
+  end
+
   # @overload min_index(axis: nil)
   #   @return [Integer, CArray] where the byte-smallest string sits.
   def min_index (*args, **kw)
@@ -217,6 +229,68 @@ class CAConstString
     to_string.max_index(*args, **kw)
   end
 
+  # @overload min_addr(axis: nil)
+  #   @return [Integer, CArray] the flat address of the byte-smallest string.
+  def min_addr (*args, **kw)
+    to_string.min_addr(*args, **kw)
+  end
+
+  # @overload max_addr(axis: nil)
+  #   @return [Integer, CArray] the flat address of the byte-largest string.
+  def max_addr (*args, **kw)
+    to_string.max_addr(*args, **kw)
+  end
+
+  # @overload bsearch(value)
+  #   @return [Integer, nil] where a sorted column holds `value`.
+  def bsearch (*args, **kw)
+    to_string.bsearch(*args, **kw)
+  end
+
+  # @overload bsearch_addr(value)
+  #   @return [Integer, nil] the flat address of `value` in a sorted column.
+  def bsearch_addr (*args, **kw)
+    to_string.bsearch_addr(*args, **kw)
+  end
+
+  # @overload search_addr(value)
+  #   @return [Integer, nil] the flat address of the first cell equal to `value`.
+  def search_addr (*args, **kw)
+    to_string.search_addr(*args, **kw)
+  end
+
+  # @overload match(pattern)
+  #   @return [CArray] boolean, as {CAString} answers.
+  def match (*args)
+    to_string.match(*args)
+  end
+
+  # @!method pmax(other)
+  #   The later String in byte order of each cell and `other`.
+  #   @return [CAConstString]
+  # @!method pmin(other)
+  #   The earlier String in byte order of each cell and `other`.
+  #   @return [CAConstString]
+  # @!method maximum(other)
+  #   Another name of {#pmax}.
+  #   @return [CAConstString]
+  # @!method minimum(other)
+  #   Another name of {#pmin}.
+  #   @return [CAConstString]
+  # @!method fmax(other)
+  #   Another name of {#pmax}.
+  #   @return [CAConstString]
+  # @!method fmin(other)
+  #   Another name of {#pmin}.
+  #   @return [CAConstString]
+  CArray.send(:define_named_methods, self,
+              [:pmax, :pmin, :maximum, :minimum, :fmax, :fmin], :pick_among_strings)
+
+  private def pick_among_strings (op, other)
+    refuse_unordered_operands(op, other)
+    const_string_lift(to_string.public_send(op, string_operand(other)))
+  end
+
   # @overload partition_copy(kth, axis: nil)
   #   @return [CAConstString] partitioned about the `kth` string in order.
   def partition_copy (*args, **kw)

data/lib/carray/construct.rb

@@ -191,7 +191,7 @@ class CArray
     extend DataTypeNewConstructor
     extend DataTypeExtension
     # @!visibility private
-    TypeSymbol = :complex64
+    TypeSymbol = :cmplx64
     # @!visibility private
     DataType   = CA_CMPLX64
   end
@@ -208,7 +208,7 @@ class CArray
     extend DataTypeNewConstructor
     extend DataTypeExtension
     # @!visibility private
-    TypeSymbol = :complex128
+    TypeSymbol = :cmplx128
     # @!visibility private
     DataType   = CA_CMPLX128
   end