carray 1.3.6 → 1.5.3

data/lib/carray/ordering.rb

@@ -0,0 +1,181 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/ordering.rb
+#
+#  This file is part of Ruby/CArray extension library.
+#
+#  Copyright (C) 2005-2020 Hiroki Motoyoshi
+#
+# ----------------------------------------------------------------------------
+
+class CArray
+  
+  # reversed
+  def reversed
+    return self[*([-1..0]*ndim)]
+  end
+  
+  # roll / shift
+
+  def shift! (*argv, &block)
+    self[] = self.shifted(*argv, &block)
+    return self
+  end
+
+  def shift (*argv, &block)
+    return self.shifted(*argv, &block).to_ca
+  end
+
+  def rolled (*argv)
+    argv.push({:roll => Array.new(ndim){1} })
+    return shifted(*argv)
+  end
+
+  def roll! (*argv)
+    self[] = self.rolled(*argv)
+    return self
+  end
+
+  def roll (*argv)
+    return self.rolled(*argv).to_ca
+  end
+    
+  # Returns the reference which elements are sorted by the comparison method
+  # given as block
+  def sorted_by (type=nil, opt={}, &block)
+    type, bytes =
+      CArray.guess_type_and_bytes(type||data_type, opt[:bytes]||bytes)
+    cmpary = convert(type, :bytes=>bytes, &block)
+    return self[cmpary.sort_addr]
+  end
+
+  # Returns the array which elements are sorted by the comparison method
+  # given as block
+  def sort_by (type=nil, opt={}, &block)
+    type, bytes =
+      CArray.guess_type_and_bytes(type||data_type, opt[:bytes]||bytes)
+    cmpary = convert(type, :bytes=>bytes, &block)
+    return self[cmpary.sort_addr].to_ca
+  end
+  
+  def sorted_with (*others)
+    addr = sort_addr
+    ([self] + others).map { |x| x[addr] }
+  end
+
+  def sort_with (*others)
+    addr = sort_addr
+    ([self] + others).map { |x| x[addr].to_ca }
+  end
+
+  def max_by (&block)
+    if empty?
+      return UNDEF
+    else
+      addr = convert(:object, &block).max_addr
+      return self[addr]
+    end
+  end
+
+  def max_with (*others)
+    if empty?
+      return ([self] + others).map { |x| UNDEF }
+    else
+      addr = max_addr
+      return ([self] + others).map { |x| x[addr] }
+    end
+  end
+
+  def min_by (&block)
+    if empty?
+      return UNDEF
+    else
+      addr = convert(:object, &block).min_addr
+      return self[addr]
+    end
+  end
+
+  def min_with (*others)
+    if empty?
+      return ([self] + others).map { |x| UNDEF }
+    else
+      addr = min_addr
+      return ([self] + others).map { |x| x[addr] }
+    end
+  end
+
+  def range 
+    return (self.min)..(self.max)
+  end
+
+  def nlargest (n)
+    obj = self.to_ca
+    list = []
+    n.times do |i|
+      k = obj.max_addr
+      list << obj[k]
+      obj[k] = UNDEF
+    end
+    list.to_ca.to_type(data_type)
+  end
+
+  def nlargest_addr (n)
+    obj = self.to_ca
+    list = []
+    n.times do |i|
+      k = obj.max_addr
+      list << k
+      obj[k] = UNDEF
+    end
+    CA_INT64(list)
+  end
+
+  def nsmallest (n)
+    obj = self.to_ca
+    list = []
+    n.times do |i|
+      k = obj.min_addr
+      list << obj[k]
+      obj[k] = UNDEF
+    end
+    list.to_ca.to_type(data_type)
+  end
+
+  def nsmallest_addr (n)
+    obj = self.to_ca
+    list = []
+    n.times do |i|
+      k = obj.min_addr
+      list << k
+      obj[k] = UNDEF
+    end
+    CA_INT64(list)
+  end
+
+  def order (dir = 1)
+    if dir >= 0   ### ascending order
+      if has_mask?
+        obj = template(:int32) { UNDEF }
+        sel = is_not_masked
+        obj[sel][self[sel].sort_addr].seq!
+        return obj
+      else
+        obj = template(:int32)
+        obj[sort_addr].seq!
+        return obj
+      end
+    else           ### descending order
+      if has_mask?
+        obj = template(:int32) { UNDEF}
+        sel = is_not_masked
+        obj[sel][self[sel].sort_addr.reversed].seq!
+        return obj
+      else  
+        obj = template(:int32)
+        obj[sort_addr.reversed].seq!
+        return obj
+      end
+    end
+  end
+
+end

data/lib/carray/{base/serialize.rb → serialize.rb}

@@ -1,12 +1,10 @@
 # ----------------------------------------------------------------------------
 #
-#  carray/base/serialize.rb
+#  carray/serialize.rb
 #
 #  This file is part of Ruby/CArray extension library.
-#  You can redistribute it and/or modify it under the terms of
-#  the Ruby Licence.
 #
-#  Copyright (C) 2005 Hiroki Motoyoshi
+#  Copyright (C) 2005-2020 Hiroki Motoyoshi
 #
 # ----------------------------------------------------------------------------
 #
@@ -33,7 +31,7 @@
 # offset 20 bytes
 #   data_type        : int32  : data type specifier
 #   bytes            : int32  : byte size of each data
-#   rank             : int32  : rank of array
+#   ndim             : int32  : ndim of array
 #   elements         : int32  : number of all elements
 #   has_mask         : int32  : 0 (not masked) or 1 (masked)
 # offset 40 bytes
@@ -41,8 +39,10 @@
 #   has_attribute    : int32  
 #
 # offset 256 bytes
-#   data           : bytes*elements : value data
-#   mask           : int8*elements  : mask data if has_mask == 1
+#   data             : bytes*elements : value data
+#   mask             : int8*elements  : mask data if has_mask == 1
+#   attribute        : object marshal : attribute
+#   data_class_name  : string marshal : data_class_name
 
 require "stringio"
 
@@ -54,11 +54,25 @@ class CArray::Serializer   # :nodoc:
     char_p    :endian,         :bytes=>4
     int32     :data_type
     int64     :bytes
-    int32     :rank
+    int32     :ndim
     int64     :elements
     int32     :has_mask
     array     :dim,            :type => CArray.int64(CA_RANK_MAX)
     int32     :has_attr
+    int32     :has_data_class
+  }
+
+  Header_Legacy = CA.struct(:pack=>1, :size=>256) {
+    char_p    :magic_string,   :bytes=>8
+    char_p    :data_type_name, :bytes=>8
+    char_p    :endian,         :bytes=>4
+    int32     :data_type
+    int32     :bytes
+    int32     :ndim
+    int32     :elements
+    int32     :has_mask
+    array     :dim,            :type => CArray.int32(CA_RANK_MAX)
+    int32     :has_attr
   }
 
   def initialize (io)
@@ -79,18 +93,19 @@ class CArray::Serializer   # :nodoc:
     header[:endian]         = ( endian == CA_LITTLE_ENDIAN ) ? "_LE_" : "_BE_"
     header[:data_type]      = ca.data_type
     header[:bytes]          = ca.bytes
-    header[:rank]           = ca.rank
+    header[:ndim]           = ca.ndim
     header[:elements]       = ca.elements
     header[:has_mask]       = ca.has_mask? ? 1 : 0
-    header[:dim][[0,ca.rank]] = ca.dim
-    attr = nil
+    header[:has_data_class] = ca.has_data_class? ? 1 : 0
+    header[:dim][[0,ca.ndim]] = ca.dim
+    attributes = nil
     if ca.attribute
-      attr = ca.attribute.clone
+      attributes = ca.attribute.clone
     end
     if opt[:attribute]
-      (attr ||= {}).update(opt[:attribute])
+      (attributes ||= {}).update(opt[:attribute])
     end
-    header[:has_attr]       = attr.empty? ? 0 : 1
+    header[:has_attr]       = attributes.empty? ? 0 : 1
     unless CArray.endian == endian
       header.swap_bytes!
     end
@@ -108,14 +123,21 @@ class CArray::Serializer   # :nodoc:
     if ca.has_mask?
       ca.mask.dump_binary(@io)
     end
-    if attr
-      Marshal.dump(attr, @io)
+    if attributes
+      Marshal.dump(attributes, @io)
+    end
+    if ca.has_data_class?
+      Marshal.dump(ca.data_class.to_s, @io)
     end
     return ca
   end
   
-  def load (opt = {})
-    header = Header.decode(@io.read(256))
+  def load (opt = {}, legacy: false)
+    if legacy
+      header = Header_Legacy.decode(@io.read(256))
+    else
+      header = Header.decode(@io.read(256))
+    end
     if header[:magic_string] != "_CARRAY_"
       raise "not a CArray binary data"      
     end
@@ -130,11 +152,12 @@ class CArray::Serializer   # :nodoc:
     end
     data_type = header[:data_type]
     bytes     = header[:bytes]
-    rank      = header[:rank]
+    ndim      = header[:ndim]
     elements  = header[:elements]
     has_mask  = header[:has_mask] != 0 ? true : false
-    dim       = header[:dim][[0, rank]].to_a
-    has_attr  = header[:has_attr]
+    dim       = header[:dim][[0, ndim]].to_a
+    has_attr  = header[:has_attr] != 0 ? true : false
+    has_data_class = header[:has_data_class] != 0 ? true : false
     if data_type == 255
       data_type = header[:data_type_name].strip.to_sym
     end
@@ -155,9 +178,12 @@ class CArray::Serializer   # :nodoc:
       ca.mask = 0
       ca.mask.load_binary(@io)
     end
-    if has_attr == 1
+    if has_attr
       ca.attribute = Marshal.load(@io)
     end
+    if has_data_class 
+      ca.data_class = Kernel.const_get(Marshal.load(@io))
+    end
     return ca
   end
   
@@ -202,7 +228,8 @@ class CArray
 
   def marshal_dump ()
     if self.class != CArray and self.class != CScalar
-      raise TypeError, "can't dump a virtual or wrapped array."
+      return CArray.dump(self.to_ca)
+#      raise TypeError, "can't dump a virtual or wrapped array."
     end
     return CArray.dump(self)
   end
@@ -213,48 +240,5 @@ class CArray
     initialize_copy(ca)
   end
 
-  ### obsolete methods
-
-  def save_binary (filename, opt={})    # :nodoc: 
-    warn "CArray#save_binary will be obsolete, use CArray.save"
-    open(filename, "w") { |io|
-      return Serializer.new(io).save(self, opt)
-    }
-  end
-
-  def self.load_binary (filename, opt={})     # :nodoc: 
-    warn "CArray.load_binary will be obsolete, use CArray.load"
-    open(filename) { |io|
-      return Serializer.new(io).load(opt)
-    }
-  end
-
-  def save_binary_io (io, opt={})        # :nodoc:
-    warn "CArray#save_binary_io will be obsolete, use CArray.save"
-    return Serializer.new(io).save(self, opt) 
-  end
-
-  def self.load_binary_io (io, opt={})   # :nodoc:
-    warn "CArray#load_binary_io will be obsolete, use CArray.load"
-    return Serializer.new(io).load(opt)   
-  end 
-
-  def to_binary (io="", opt={})          # :nodoc:
-    warn "CArray#to_binary will be obsolete, use CArray.dump"
-    Serializer.new(io).save(self, opt) 
-    return io
-  end
-
-  def self.from_binary (io, opt={})      # :nodoc:
-    warn "CArray.from_binary will be obsolete, use CArray.load"
-    return Serializer.new(io).load(opt)   
-  end 
-
-  # depleted methods
-
-  def self.load_from_file (filename, data_type, dim, opt={}) # :nodoc:
-    raise "Sorry, CArray.load_from_file is depleted"
-  end
-
 end
 

data/lib/carray/string.rb

@@ -0,0 +1,188 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/string.rb
+#
+#  This file is part of Ruby/CArray extension library.
+#
+#  Copyright (C) 2005-2020 Hiroki Motoyoshi
+#
+# ----------------------------------------------------------------------------
+
+require "date"
+
+class CArray
+
+  def str_len ()
+    return convert(:int, &:length)
+  end
+
+  def str_size ()
+    return convert(:int, &:size)
+  end
+
+  def str_bytesize ()
+    return convert(:int, &:bytesize)
+  end
+
+  def str_gsub (*args, &block)
+    return convert() {|s| s.gsub(*args, &block) }
+  end
+
+  def str_sub (*args, &block)
+    return convert() {|s| s.sub(*args, &block) }
+  end
+
+  def str_encode (*args)
+    return convert() {|s| s.encode(*args) }
+  end
+
+  def str_force_encoding (encoding)
+    return convert() {|s| s.force_encoding(encoding) }
+  end
+
+  def str_encoding ()
+    return convert(&:encoding)
+  end
+
+  def str_is_end_with (*args)
+    return test {|s| s.end_with?(*args) }
+  end
+
+  def str_is_start_with (*args)
+    return test {|s| s.start_with?(*args) }
+  end
+
+  def str_includes (substr)
+    return test {|s| s.include?(substr) }
+  end
+
+  alias str_contains str_includes
+
+  def str_index (*args)
+    return convert(:int) {|s| s.index(*args) }
+  end
+
+  def str_rindex (*args)
+    return convert(:int) {|s| s.rindex(*args) }
+  end
+
+  def str_intern ()
+    return convert(&:intern)
+  end
+
+  def str_scrub ()
+    return convert(&:scrub)
+  end
+
+  def str_downcase ()
+    return convert(&:downcase)
+  end
+
+  def str_upcase ()
+    return convert(&:upcase)
+  end
+
+  def str_capitalize ()
+    return convert(&:capitalize)
+  end
+
+  def str_swapcase ()
+    return convert(&:swapcase)
+  end
+
+  def str_chomp (*args)
+    return convert() {|s| s.chomp(*args) }
+  end
+
+  def str_chop ()
+    return convert(&:chop)
+  end
+
+  def str_chr ()
+    return convert(&:chr)
+  end
+
+  def str_clear ()
+    return convert(&:clear)
+  end
+
+  def str_count (*args)
+    return convert(:int) {|s| s.count(*args) }
+  end
+
+  def str_delete (*args)
+    return convert() {|s| s.delete(*args) }
+  end
+
+  def str_delete_prefix (prefix)
+    return convert() {|s| s.delete_prefix(prefix) }
+  end
+
+  def str_delete_suffix (suffix)
+    return convert() {|s| s.delete_suffix(suffix) }
+  end
+
+  def str_dump ()
+    return convert(&:dump)
+  end
+
+  def str_center (*args)
+    return convert() {|s| s.center(*args) }
+  end
+
+  def str_ljust (*args)
+    return convert() {|s| s.ljust(*args) }
+  end
+
+  def str_rjust (*args)
+    return convert() {|s| s.rjust(*args) }
+  end
+
+  def str_to_i ()
+    return convert(&:to_i)
+  end
+
+  def str_to_f ()
+    return convert(&:to_f)
+  end
+
+  def str_to_r ()
+    return convert(&:to_r)
+  end
+
+  def str_strip ()
+    return convert(&:strip)
+  end
+
+  def str_rstrip ()
+    return convert(&:rstrip)
+  end
+
+  def str_lstrip ()
+    return convert(&:lstrip)
+  end
+
+  def str_is_empty ()
+    return test(&:empty?)
+  end
+
+  def str_matches (*args)
+    if args.size == 1 && args.first.is_a?(Regexp)
+      regexp = args.first
+      return test {|v| v =~ regexp }
+    else
+      mask = template(:boolean) { false }
+      args.each do |str|
+        addr = search(str)
+        mask[addr] = true if addr
+      end
+      return mask
+    end
+  end
+  
+  def str_extract (regexp, replace = '\0')
+    return convert {|s| regexp.match(s) {|m| m[0].sub(regexp, replace) } || "" }
+  end
+    
+end
+