carray 1.4.0 → 1.5.5

data/lib/carray/math/histogram.rb

@@ -3,10 +3,8 @@
 #  carray/math/histogram.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
 #
 # ----------------------------------------------------------------------------
 
@@ -49,7 +47,7 @@ class CAHistogram < CArray
       raise "scales should be an array of scales"
     end
 
-    rank = scales.size
+    ndim = scales.size
     @scales = scales.clone
     @scales.map! { |s| CArray.wrap_readonly(s, CA_DOUBLE) }
     
@@ -60,10 +58,10 @@ class CAHistogram < CArray
         raise "invalid length of offset in option"
       end
     else
-      @offsets = Array.new(rank) { 0 }
+      @offsets = Array.new(ndim) { 0 }
     end
 
-    dim = Array.new(rank) { |i| 
+    dim = Array.new(ndim) { |i| 
       case @offsets[i]
       when 0
         @scales[i].size
@@ -76,12 +74,12 @@ class CAHistogram < CArray
     
     super(data_type, dim, &block)
 
-    @mid_points = Array.new(rank) { |i|
+    @mid_points = Array.new(ndim) { |i|
       x = (@scales[i] + @scales[i].shifted(-1))/2
       x[0..-2].to_ca
     }
 
-    @inner = self[*Array.new(rank) { |i| @offsets[i]..-2 }]
+    @inner = self[*Array.new(ndim) { |i| @offsets[i]..-2 }]
 
   end
 
@@ -91,7 +89,7 @@ class CAHistogram < CArray
   alias midpoints mid_points
 
   def increment (*values)
-    idx = Array.new(rank) {|i|
+    idx = Array.new(ndim) {|i|
       vi = CArray.wrap_readonly(values[i], CA_DOUBLE)
       @scales[i].bin(vi, @include_upper, @include_lowest, @offsets[i]).to_ca
     }
@@ -103,7 +101,7 @@ class CAHistogram < CArray
     val = CArray.wrap_readonly(values.pop, self.data_type)
     sel = val.ne(0)
     val = val[sel].to_ca
-    idx = Array.new(rank) {|i|
+    idx = Array.new(ndim) {|i|
       vi = CArray.wrap_readonly(values[i], CA_DOUBLE)[sel]
       @scales[i].bin(vi, @include_upper, @include_lowest, @offsets[i]).to_ca
     }

data/lib/carray/math/recurrence.rb

@@ -3,10 +3,8 @@
 #  carray/math/recurrence.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/mkmf.rb

@@ -3,10 +3,8 @@
 #  carray/mkmf.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
 #
 # ----------------------------------------------------------------------------
 
@@ -18,6 +16,13 @@ def have_carray
   rescue LoadError
     abort "Ruby/CArray is not installed"
   end
+  $LOAD_PATH.each do |path|
+    if File.exist? File.join(path, 'carray.h')
+      dir_config("carray", path, path)      
+      break
+    end
+  end
+=begin  
   dir_config("carray", $sitearchdir, $sitearchdir)
   if defined? Gem
     if Gem::VERSION >= "1.7.0"
@@ -34,6 +39,7 @@ def have_carray
       end
     end
   end
+=end
   status = true
   status &= have_header("carray.h")
   if /cygwin|mingw/ =~ RUBY_PLATFORM

data/lib/carray/object/ca_obj_iterator.rb

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

data/lib/carray/object/ca_obj_link.rb

@@ -3,10 +3,8 @@
 #  carray/object/ca_obj_link.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/object/ca_obj_pack.rb

@@ -3,10 +3,8 @@
 #  carray/object/ca_obj_pack.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
 #
 # ----------------------------------------------------------------------------
 
@@ -22,9 +20,9 @@ class CAPack < CAObject # :nodoc:
 
   def initialize (list, options={})
     @list   = list
-    @rank   = options[:rank]
-    unless @rank
-      @rank = list.map{|m| m.rank}.min
+    @ndim   = options[:ndim]
+    unless @ndim
+      @ndim = list.map{|m| m.ndim}.min
     end
     @names  = options[:names] || [nil]*@list.size
     @dim    = guess_dim(list)
@@ -55,10 +53,10 @@ class CAPack < CAObject # :nodoc:
     list.each do |mem|
       case mem
       when CArray
-        if mem.rank < @rank
-          raise "mem.rank < @rank"
+        if mem.ndim < @ndim
+          raise "mem.ndim < @ndim"
         else
-          newdim = mem.dim[0, @rank]
+          newdim = mem.dim[0, @ndim]
         end
         if dim
           unless dim == newdim
@@ -78,10 +76,10 @@ class CAPack < CAObject # :nodoc:
         name = @names[i]
         case mem
         when CArray
-          if mem.rank == @rank
+          if mem.ndim == @ndim
             s.member mem.data_type, name, :bytes=>mem.bytes ### anonymous member
           else
-            dummy = Array.new(@rank){0} + [false]
+            dummy = Array.new(@ndim){0} + [false]
             s.member mem[*dummy].to_ca, name                ### anonymous member
           end
         else

data/lib/carray/obsolete.rb

@@ -0,0 +1,256 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/obsolete.rb
+#
+#  This file is part of Ruby/CArray extension library.
+#
+#  Copyright (C) 2005-2020 Hiroki Motoyoshi
+#
+# ----------------------------------------------------------------------------
+
+module CA
+  TableMethods = CArray::TableMethods
+end
+
+class CArray
+  
+  ### obsolete methods
+
+  def extend_as_table (column_names)
+    warn "CArray#extend_as_table will be obsolete"
+    self.extend CArray::TableMethods
+    self.column_names = column_names
+    self
+  end
+
+  # Returns the array eliminated all the duplicated elements.
+  def duplicated_values
+    warn "CArray#duplicated_values will be obsolete"
+    if uniq.size == size
+      return []
+    else
+      hash = {}
+      list = []
+      each_with_addr do |v, addr|
+        if v == UNDEF
+          next
+        elsif hash[v]
+          list << [v, addr, hash[v]]
+          hash[v] += 1
+        else
+          hash[v] = 0
+        end
+      end
+      return list
+    end
+  end
+
+  def self.summation (*dim)
+    warn "CArray.summation will be obsolete"
+    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)
+    warn "CArray#by will be obsolete"
+    case other
+    when CArray
+      return (self[nil][nil,:*]*other[nil][:*,nil]).reshape(*(dim+other.dim))
+    else
+      return self * other
+    end
+  end
+
+  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 
+
+  def replace_value (from, to)
+    warn "CArray#replace_value will be obsolete"
+    self[:eq, from] = to
+    return self
+  end
+  
+  def asign (*idx)
+    warn "CArray#asign will be obsolete"
+    self[*idx] = yield
+    return self
+  end
+  
+  def fa                               # :nodoc:
+    warn "CArray#fa will be obsolete, use CArray#t"
+    return self.t
+  end
+
+  def block_iterator (*argv)           # :nodoc:
+    warn "CArray#block_iterator will be obsolete, use CArray#blocks"
+    return blocks(*argv)
+  end
+
+  def window_iterator (*argv)          # :nodoc:
+    warn "CArray#window_iterator will be obsolete, use CArray#windows"
+    return windows(*argv)
+  end
+
+  def rotated (*argv)                  # :nodoc:
+    warn "CArray#rotated will be obsolete, use CArray#rolled"
+    argv.push({:roll => Array.new(ndim){1} })
+    return shifted(*argv)
+  end
+
+  def rotate! (*argv)                  # :nodoc:
+    warn "CArray#rotate! will be obsolete, use CArray#roll!"
+    self[] = self.rolled(*argv)
+    return self
+  end
+
+  def rotate (*argv)                   # :nodoc:
+    warn "CArray#rotate will be obsolete, use CArray#roll"
+    return self.rolled(*argv).to_ca
+  end
+
+  def select (&block)                  # :nodoc:
+    warn "CArray#select will be obsolete"
+    case block.arity
+    when 1
+      return self[*yield(self)]
+    when -1, 0
+      return self[*instance_exec(&block)]
+    else
+      raise
+    end
+  end
+
+  def transform (type, dim, opt = {}) # :nodoc:
+    warn("CArray#transform will be obsolete")
+    return refer(type, dim, opt).to_ca
+  end
+  
+  def classify (klass, outlier = nil)  # :nodoc:
+    warn "CArray#classify will be obsolete"
+    b = CArray.int32(*dim)
+    f = CArray.boolean(*dim) { 1 }
+    attach {
+      (klass.elements-1).times do |i|
+        r = f.and(self < klass[i+1])
+        b[r] = i
+        f[r] = 0
+      end
+      if outlier
+        b[self < klass[0]] = outlier
+        b[f] = outlier
+      else
+        b[self < klass[0]] = -1
+        b[f] = klass.elements-1
+      end
+    }
+    return b
+  end
+
+
+
+end
+
+=begin
+
+class Numeric
+  
+  [
+    :boolean,
+    :int8,
+    :uint8,
+    :int16,
+    :uint16,
+    :int32,
+    :uint32,
+    :int64,
+    :uint64,
+    :float32,
+    :float64,
+    :float128,
+    :cmplx64,
+    :cmplx128,
+    :cmplx256,
+    :byte,
+    :short,
+    :int,
+    :float,
+    :double,
+    :complex,
+    :dcomplex,
+    :object
+  ].each do |name|
+    class_eval %{
+      def #{name} ()
+        warn "Numeric##{name} will be obsolete"
+        CScalar.new(#{name.inspect}) {self}
+      end
+    }
+  end
+
+end
+
+class CArray
+  def histogram (klass)
+    c = CArray.int32(klass.elements-1)
+    f = CArray.boolean(*dim) { 1 }
+    attach {
+      k = 0
+      r = f.and(self < klass[0])
+      f[r] = 0
+      (klass.elements-1).times do |i|
+        r = f.and(self < klass[i+1])
+        c[k] = r.count_true
+        f[r] = 0
+        k+=1
+      end
+    }
+    return c
+  end
+
+  def self.load_from_file (filename, data_type, dim, opt={}) # :nodoc:
+    raise "Sorry, CArray.load_from_file is depleted"
+  end
+
+end
+=end

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