carray 1.3.6 → 1.5.3

data/lib/carray/convert.rb

@@ -0,0 +1,115 @@
+
+
+
+class CArray
+
+  #
+  # Returns the 8-bit integer CArray object filled with 0 which
+  # dimension size is same as +self+. The resulted array represents
+  # the logical array which has +false+ for its all elements.
+  #
+  def false ()
+    return template(:boolean)
+  end
+
+  #
+  # Returns the 8-bit integer CArray object filled with 1 which
+  # dimension size is same as +self+. The resulted array represents
+  # the logical array which has +true+ for its all elements.
+  #
+  def true ()
+    return template(:boolean) { 1 }
+  end
+
+  # Returns map
+  def map (&block)
+    return self.convert(CA_OBJECT, &block).to_a
+  end
+
+  #
+  #  ref = CA_INT([[0,1,2],[1,2,0],[2,0,1]])
+  #  a = CArray.int(3,3).seq(1)
+  #  b = CArray.int(3,3).seq(11)
+  #  c = CArray.int(3,3).seq(21)
+  #
+  #  CArray.pickup(CA_OBJECT, ref, [a,b,c])
+  #  => <CArray.object(3,3): elem=9 mem=72b
+  #  [ [ 1, 12, 23 ],
+  #    [ 14, 25, 6 ],
+  #    [ 27, 8, 19 ] ]>
+  #
+  #  CArray.pickup(CA_OBJECT, ref, ["a","b","c"])
+  #  => <CArray.object(3,3): elem=9 mem=36b
+  #  [ [ "a", "b", "c" ],
+  #    [ "b", "c", "a" ],
+  #    [ "c", "a", "b" ] ]>
+  #
+  def self.pickup (data_type, ref, args)
+    out = ref.template(data_type)
+    args.each_with_index do |v, i|
+      s = ref.eq(i)
+      case v
+      when CArray
+        out[s] = v[s]
+      else
+        out[s] = v
+      end
+    end
+    return out
+  end
+
+  # Array#join like method
+  #
+  # > a = CArray.object(3,3).seq("a",:succ)
+  # => <CArray.object(3,3): elem=9 mem=72b
+  # [ [ "a", "b", "c" ],
+  #   [ "d", "e", "f" ],
+  #   [ "g", "h", "i" ] ]>
+  # 
+  # > a.join("\n",",")
+  # => "a,b,c\nd,e,f\ng,h,i"
+  #
+
+  def join (*argv)
+    case argv.size
+    when 0
+      return to_a.join()
+    when 1
+      sep = argv.shift
+      return to_a.join(sep)
+    else
+      sep = argv.shift
+      return self[:i, false].map { |s|
+          s[0, false].join(*argv)
+      }.join(sep)
+    end
+  end
+    
+  # 
+  def to_bit_string (nb)
+    hex = CArray.uint8(((nb*elements)/8.0).ceil)
+    hex.bits[nil].paste([0], self.bits[false,[(nb-1)..0]].flatten)
+    hex.bits[] = hex.bits[nil,[-1..0]]
+    return hex.to_s
+  end
+
+  def from_bit_string (bstr, nb)
+    hex = CArray.uint8(bstr.length).load_binary(bstr)
+    hex.bits[] = hex.bits[nil,[-1..0]]
+    bits = hex.bits.flatten
+    self.bits[false,[(nb-1)..0]][nil].paste([0], bits)
+    return self
+  end
+
+  def self.from_bit_string (bstr, nb, data_type=CA_INT32, dim=nil)
+    if dim
+      obj = CArray.new(data_type, dim)
+    else
+      dim0 = ((bstr.length*8)/nb.to_f).floor
+      obj = CArray.new(data_type, [dim0])
+    end
+    obj.from_bit_string(bstr, nb)
+    return obj
+  end
+  
+end

data/lib/carray/info.rb

@@ -3,10 +3,8 @@
 #  carray/info.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
 #
 # ----------------------------------------------------------------------------
 

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

@@ -1,12 +1,10 @@
 # ----------------------------------------------------------------------------
 #
-#  carray/base/inspect.rb
+#  carray/inspect.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
 #
 # ----------------------------------------------------------------------------
 
@@ -17,14 +15,14 @@ class CArray::Inspector  # :nodoc:
   end
 
   def inspect_string
-    if @carray.rank == 0
-      raise "can't inspect CArray of rank == 0"
+    if @carray.ndim == 0
+      raise "can't inspect CArray of ndim == 0"
     end
     formatter  = get_formatter()
     class_name = get_class_name()
     type_name  = get_type_name()
     shape      = get_shape()
-    data_spec  = get_data_spec(0, Array.new(@carray.rank){0}, formatter)
+    data_spec  = get_data_spec(0, Array.new(@carray.ndim){0}, formatter)
     info_list  = get_info_list()
     output = ["<",
               format("%s.%s(%s)", class_name, type_name, shape.join(",")),
@@ -152,14 +150,14 @@ class CArray::Inspector  # :nodoc:
 
   def get_data_spec (level, idx, formatter)
     io = "[ "
-    rank = @carray.rank
+    ndim = @carray.ndim
     dim  = @carray.dim
-    if level == rank - 1
+    if level == ndim - 1
       over = false
       dim[level].times do |i|
         idx[level] = i
         v = @carray[*idx]
-        if v.undef?
+        if v == UNDEF
           io << '_'
         else
           io << formatter[v]
@@ -178,7 +176,7 @@ class CArray::Inspector  # :nodoc:
       if over
         idx[level] = dim[level] - 1
         v = @carray[*idx]
-        if v.undef?
+        if v == UNDEF
           io << ", _"
         else
           io << ", " + formatter[v]

data/lib/carray/io/imagemagick.rb

@@ -3,10 +3,8 @@
 #  carray/io/imagemagick.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
 #
 # ----------------------------------------------------------------------------
 
@@ -121,7 +119,7 @@ class CArray
 
   def magick_guess_image_type
     image_type = nil
-    case rank
+    case ndim
     when 2
       if fixlen?
         case bytes

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

@@ -1,12 +1,10 @@
 # ----------------------------------------------------------------------------
 #
-#  carray/base/iterator.rb
+#  carray/iterator.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
 #
 # ----------------------------------------------------------------------------
 
@@ -280,6 +278,7 @@ class CAIterator
   end
 
   def sort_with (&block)
+    warn "CAIterator#sort_with will be obsolete"
     out = reference.template
     idx = CA.sort_addr(*yield(self))
     ca[idx].each_with_addr do |blk, i|
@@ -317,8 +316,9 @@ class CAClassIterator < CAIterator # :nodoc:
     @reference = reference
     @classifier = classifier || @reference.uniq.sort
     @null = CArray.new(@reference.data_type,[0])
+    @null.data_class = @reference.data_class if @reference.has_data_class?
     @table = {}
-    @rank = 1
+    @ndim = 1
     @dim  = [0]
     if @classifier.all_masked? or @classifier.size == 0
       @dim  = [0]
@@ -343,7 +343,7 @@ class CAClassIterator < CAIterator # :nodoc:
     return self
   end
   
-  def ranking (&block)
+  def ndiming (&block)
     block ||= lambda {|a| a.size }
     values = self.to_a.map{|v| block[v] }.to_ca
     addrs  = values.sort_addr.reverse

data/lib/carray/mask.rb

@@ -0,0 +1,102 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/mask.rb
+#
+#  This file is part of Ruby/CArray extension library.
+#
+#  Copyright (C) 2005-2020 Hiroki Motoyoshi
+#
+# ----------------------------------------------------------------------------
+
+class CArray
+
+  # Guard methods for handling variables that can be UNDEF values.
+  # Provide different processing depending on whether 
+  # the given value is UNDEF or not.
+  #
+  # @param value [Object] target object
+  # @param fill_value [Object] alternative value if the given value is UNDEF
+  # 
+  # @return fill_value if the given value is UNDEF, block return value if block
+  #         is given, or value itself
+  #
+  def self.guard_undef (*values, fill_value: UNDEF, &block)
+    return fill_value if values.any?{|v| v == UNDEF }
+    return block.(*values)
+  end
+
+  # mask
+  # 
+  # Returns the number of masked elements.
+  # 
+  def count_masked (*axis)
+    if has_mask?  
+      return mask.int64.accumulate(*axis)
+    else
+      if axis.empty?
+        return 0
+      else
+        spec = shape.map{:i}
+        axis.each do |k|
+          spec[k] = nil
+        end
+        return self[*spec].ca.template(:int64) { 0 }
+      end
+    end
+  end
+
+  #
+  # Returns the number of not-masked elements.
+  #
+  def count_not_masked (*axis)
+    if has_mask?
+      return mask.not.int64.accumulate(*axis)
+    else
+      if axis.empty?
+        return elements
+      else
+        spec = shape.map {:i}
+        axis.each do |k|
+          spec[k] = nil
+        end
+        it = self[*spec].ca
+        count = self.elements/it.elements
+        return it.template(:int64) { count }
+      end
+    end
+  end
+
+  def maskout! (*argv)
+    case argv.size
+    when 1
+      val = argv.first
+      case val
+      when CArray, Symbol
+        self[val] = UNDEF
+      else
+        self[:eq, val] = UNDEF
+      end
+    else
+      self[*argv] = UNDEF          
+    end
+    return self
+  end
+
+  def maskout (*argv)
+    obj = self.to_ca
+    case argv.size
+    when 1
+      val = argv.first
+      case val
+      when CArray, Symbol
+        obj[val] = UNDEF
+      else
+        obj[:eq, val] = UNDEF
+      end
+    else
+      obj[*argv] = UNDEF      
+    end
+    return obj
+  end
+  
+end

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

@@ -1,12 +1,10 @@
 # ----------------------------------------------------------------------------
 #
-#  carray/base/math.rb
+#  carray/math.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
 #
 # ----------------------------------------------------------------------------
 
@@ -148,7 +146,7 @@ class CArray
   def quo (other)
     case 
     when integer?
-      return double/other
+      return object.quo_i(other)
     when object?
       return quo_i(other)
     else
@@ -226,7 +224,7 @@ class CArray
 
   def anomaly (*argv)
     opt = argv.last.is_a?(Hash) ? argv.pop : {}
-    idxs = Array.new(self.rank) { |i| argv.include?(i) ? :* : nil }
+    idxs = Array.new(self.ndim) { |i| argv.include?(i) ? :* : nil }
     if mn = opt[:mean]
       return self - mn[*idxs]
     else
@@ -260,7 +258,7 @@ class CArray
         return (c[(n-1)/2] + c[n/2])/2.0
       end
     else
-      raise "CArray#median is not implemented for multiple ranks"
+      raise "CArray#median is not implemented for multiple ndims"
     end
 
   end
@@ -285,27 +283,23 @@ class CArray
     end
     out = []
     begin
-    pers.each do |per|
-      if per == 100
-        out << ca[n-1]
-      elsif per >= 0 and per < 100
-        if n > 1
-          f = (n-1)*per/100.0
-          k = f.floor
-          r = f - k
-          out << (1-r)*ca[k] + r*ca[k+1]
+      pers.each do |per|
+        if per == 100
+          out << ca[n-1]
+        elsif per >= 0 and per < 100
+          if n > 1
+            f = (n-1)*per/100.0
+            k = f.floor
+            r = f - k
+            out << (1-r)*ca[k] + r*ca[k+1]
+          else
+            out << ca[0]
+          end
         else
-          out << ca[0]
+          out << CA_NAN
         end
-      else
-        out << CA_NAN
       end
     end
-  rescue
-    p self[:is_not_masked]
-    p n
-    raise
-  end
     return out
   end
   
@@ -322,7 +316,7 @@ class CArray
       count = x.count_not_masked
       xm = x.mean(:min_count => min_count)
       ym = y.mean(:min_count => min_count)
-      if ( xm.undef? or ym.undef? )
+      if ( xm == UNDEF or ym == UNDEF )
         return fill_value || UNDEF
       else
         return (x-xm).wsum(y-ym)/count
@@ -341,7 +335,7 @@ class CArray
       count = x.count_not_masked
       xm = x.mean(:min_count=>min_count)
       ym = y.mean(:min_count=>min_count)
-      if ( xm.undef? or ym.undef? )
+      if ( xm == UNDEF or ym == UNDEF )
         return fill_value || UNDEF
       else
         return (x-xm).wsum(y-ym)/(count-1)
@@ -359,7 +353,7 @@ class CArray
       y.inherit_mask(x)
       xm = x.mean(:min_count=>min_count)
       ym = y.mean(:min_count=>min_count)
-      if ( xm.undef? or ym.undef? )
+      if ( xm == UNDEF or ym == UNDEF )
         return fill_value || UNDEF
       else
         xd, yd = x-xm, y-ym
@@ -373,31 +367,5 @@ class CArray
 
 end
 
-class CArray
-
-  def self.summation (*dim)
-    out = nil
-    first = true
-    CArray.each_index(*dim) { |*idx|
-      if first
-        out = yield(*idx)
-        first = false
-      else  
-        out += yield(*idx)
-      end
-    }
-    return out
-  end
-  
-  def by (other)
-    case other
-    when CArray
-      return (self[nil][nil,:*]*other[nil][:*,nil]).reshape(*(dim+other.dim))
-    else
-      return self * other
-    end
-  end
-  
-end