carray 2.0.0 → 3.0.0

data/lib/carray/io/imagemagick.rb

@@ -1,235 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  carray/io/imagemagick.rb
-#
-#  This file is part of Ruby/CArray extension library.
-#
-#  Copyright (C) 2005-2020 Hiroki Motoyoshi
-#
-# ----------------------------------------------------------------------------
-
-#
-# carray/imagemagick.rb
-#
-# This library adds image loading/saving functions to CArray class.
-# These method uses the command line tools in ImageMagick internally.
-# ImageMagick package is required to use this library, but RMagick
-# library is not required.
-#
-# --- CArray.load_by_magick(filename[, map="rgb", data_type=nil])
-#
-# Creates a CArray object from the image file _filename_.
-# The argument _map_ should be the combination of [r|g|b|a|o|i|c|m|y|b|p].
-# The dimension of new array is determined from map's contents.
-# The data_type of array is determined automatically by the depth of image,
-# unless the data_type is not given.
-#
-# --- CArray#save_by_magick(filename[, image_type="rgb", options=""])
-#
-# Saves a CArray object to the image file _filename_.
-# The argument _image_type_ should be the one of
-#   * gray, rgb, rgba, cmyk, cmyka
-# The _options_ are passed to "convert"
-#
-# --- CArray#display_by_magick([image_type="rgb", options=""])
-#
-
-require 'yaml'
-require 'carray'
-
-class CArray
-
-  private
-  @@magick_tempfile_count = 0
-
-  public
-  def self.load_by_magick (filename, imap = "rgb", data_type = nil)
-    if not File.exist?(filename)
-      raise "can't find image file '#{filename}'"
-    end
-    identify_command = [
-                        "identify",
-                        "-format " + "'" + [
-                                           "---",
-                                           "height: %h",
-                                           "width: %w",
-                                           "depth: %z",
-                                          ].join("\n") + "'",
-                        filename,
-                        "2>/dev/null"
-                       ].join(" ")
-    ident = YAML.load(`#{identify_command}`)
-    if ident.empty?
-      raise "ImageMagick's identify command failed to read image file '#{filename}'"
-    end
-    height, width, depth = ident.values_at('height', 'width', 'depth')
-    unless data_type
-      case depth
-      when 8
-        data_type = CA_UINT8
-      when 16
-        data_type = CA_UINT16
-      when 32
-        data_type = CA_UINT32
-      end
-    end
-    storage_type = case data_type
-                   when CA_UINT8, CA_INT8
-                     "char"
-                   when CA_UINT16, CA_INT16
-                     "short"
-                   when CA_UINT32, CA_INT32
-                     "integer"
-                   when CA_FLOAT32
-                     "float"
-                   when CA_FLOAT64
-                     "double"
-                   else
-                     raise "invalid data_type"
-                   end
-#    tempfile = "CA_Magick_#{$$}_#{@@magick_tempfile_count}.dat"
-#    @@magick_tempfile_count += 1
-    stream_command = [
-                      "stream",
-                      "-storage-type #{storage_type}",
-                      "-map #{imap}",
-                      filename,
-                      "-",
-                      "2>/dev/null"
-                     ].join(" ")
-    begin
-      return IO.popen(stream_command) { |io|
-        if imap.size == 1
-          CArray.new(data_type, [height, width]).load_binary(io)
-        else
-          CArray.new(data_type, [height, width, imap.size]).load_binary(io)
-        end
-      }
-    rescue
-      raise "ImageMagick's stream command failed to read image file '#{filename}'"
-    ensure
-#      if File.exist?(tempfile)
-#        File.unlink(tempfile)
-#      end
-    end
-  end
-
-  private
-
-  def magick_guess_image_type
-    image_type = nil
-    case ndim
-    when 2
-      if fixlen?
-        case bytes
-        when 1
-          image_type = "gray"
-        when 3
-          image_type = "rgb"
-        when 4
-          image_type = "rgba"
-        end
-      else
-        image_type = "gray"
-      end
-    when 3
-      case dim2
-      when 1
-        image_type = "gray"
-      when 3
-        image_type = "rgb"
-      when 4
-        image_type = "rgba"
-      end
-    end
-    return image_type
-  end
-
-  public
-
-  def save_by_magick (filename, image_type = nil, options = "")
-    unless image_type
-      image_type = magick_guess_image_type()
-    end
-    unless image_type
-      raise "please specify image_type"
-    end
-    quantum_format = self.float? ? "-define quantum:format=floating-point" : ""
-    case self.data_type
-    when CA_INT8, CA_UINT8
-      depth = "-depth 8"
-    when CA_INT16, CA_UINT16
-      depth = "-depth 16"
-    when CA_FLOAT32
-      depth = "-depth 32"
-    when CA_FLOAT64
-      depth = "-depth 64"
-    when CA_FIXLEN
-      depth = "-depth #{8*bytes}"
-    else
-      depth = "-depth 8"
-    end
-    convert_command = [
-                       "magick convert",
-                       depth,
-                       "-size " + [dim1, dim0].join("x"),
-                       quantum_format,
-                       options,
-                       "#{image_type}:-",
-                       filename
-                      ].join(" ")
-    begin
-      IO.popen(convert_command, "w") { |io|
-        if data_type != CA_FIXLEN and data_type != CA_OBJECT
-          if bytes > 1 and CArray.endian == CA_LITTLE_ENDIAN
-            self.dump_binary(io)
-#            swap_bytes.dump_binary(io)
-          else
-            self.dump_binary(io)
-          end
-        else
-          self.dump_binary(io)
-        end
-      }
-    rescue
-      raise "ImageMagick's convert command failed to write image file '#{filename}'"
-    end
-  end
-
-  def display_by_magick (image_type = nil, options = "")
-    unless image_type
-      image_type = magick_guess_image_type()
-    end
-    unless image_type
-      raise "please specify image_type"
-    end
-    quantum_format = self.float? ? "-define quantum:format=floating-point" : ""
-    depth = fixlen? ? "-depth 8" : "-depth #{8*bytes}"
-    display_command = [
-                       "display",
-                       depth,
-                       "-size " + [dim1, dim0].join("x"),
-                       quantum_format,
-                       options,
-                       "#{image_type}:-",
-                      ].join(" ")
-    begin                  
-      IO.popen(display_command, "w") { |io|
-        if bytes > 1 and CArray.endian == CA_LITTLE_ENDIAN
-          swap_bytes.dump_binary(io)
-        else
-          self.dump_binary(io)
-        end
-      }
-    rescue
-      raise "ImageMagick's display command failed to display image"
-    end
-  end
-
-end
-
-
-
-
-
-

data/lib/carray/mask.rb

@@ -1,102 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  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/math/histogram.rb

@@ -1,177 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  carray/math/histogram.rb
-#
-#  This file is part of Ruby/CArray extension library.
-#
-#  Copyright (C) 2005-2020 Hiroki Motoyoshi
-#
-# ----------------------------------------------------------------------------
-
-#
-# N-dimensional histogram class
-#
-
-#
-# c0 : b0 <= x < b1  
-# c1 : b1 <= x < b2  
-# c2 : b2 <= x < b3  
-#
-
-require 'carray'
-
-class CAHistogram < CArray
-
-  def initialize (*argv, &block)
-
-    case argv.first
-    when Integer, String, Symbol
-      data_type = argv.shift
-    else
-      data_type = CA_INT32
-    end
-
-    scales = argv.shift
-    opt    = argv.shift || {}
-
-    option = {
-      :include_upper  => false,
-      :include_lowest => true,
-      :offsets        => nil,
-    }.update( opt )
-
-    @include_upper  = option[:include_upper]
-    @include_lowest = option[:include_lowest]    
-
-    unless scales.kind_of?(Array)
-      raise "scales should be an array of scales"
-    end
-
-    ndim = scales.size
-    @scales = scales.clone
-    @scales.map! { |s| CArray.wrap_readonly(s, CA_DOUBLE) }
-    
-    if option[:offsets]
-      if option[:offsets].size == scales.size
-        @offsets = option[:offsets]
-      else
-        raise "invalid length of offset in option"
-      end
-    else
-      @offsets = Array.new(ndim) { 0 }
-    end
-
-    dim = Array.new(ndim) { |i| 
-      case @offsets[i]
-      when 0
-        @scales[i].size
-      when 1
-        @scales[i].size + 1
-      else
-        raise "invalid offset value"
-      end
-    }
-    
-    super(data_type, dim, &block)
-
-    @mid_points = Array.new(ndim) { |i|
-      x = (@scales[i] + @scales[i].shifted(-1))/2
-      x[0..-2].to_ca
-    }
-
-    @inner = self[*Array.new(ndim) { |i| @offsets[i]..-2 }]
-
-  end
-
-  attr_reader :scales, :include_lowest, :include_upper, :offsets
-  attr_reader :mid_points, :inner
-
-  alias midpoints mid_points
-
-  def increment (*values)
-    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
-    }
-    incr_addr(index2addr(*idx))
-    self
-  end
-
-  def add (*values)
-    val = CArray.wrap_readonly(values.pop, self.data_type)
-    sel = val.ne(0)
-    val = val[sel].to_ca
-    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
-    }
-    index2addr(*idx).each_with_addr do |addr, i|
-      self[addr] += val[i]
-    end
-    self
-  end
-
-end
-
-class CArray
-  
-  def bin (val, include_upper, include_lowest, offset=0)
-
-    scales = CArray.wrap_readonly(self, CA_DOUBLE)
-    
-    x = scales.section(val)
-#    x.inherit_mask(val)
-    unless x.is_a?(CArray)
-      x = CA_DOUBLE(x)
-    end
-
-    if include_upper
-      if include_lowest
-        x[:eq, 0] = 0.5
-      end
-      xi = x.ceil.int32 - 1
-    else
-      xi = x.floor.int32 
-    end
-
-    case offset
-    when 0
-      xi[:gt, elements-1] = elements - 1
-      xi[:lt, 0] = UNDEF
-    when 1
-      xi.add!(1)
-      xi[:gt, elements] = elements
-      xi[:lt, 1] = 0
-    else
-      raise "invalid offset value"
-    end
-
-    return xi
-  end
-  
-end
-
-if __FILE__ == $0
-
-  scale = CArray.float(50).span(0..10)
-  hist  = CAHistogram.new([scale, scale])
-
-  x = CArray.float(1000000).randomn!.mul!(3).abs!
-  y = CArray.float(1000000).randomn!.mul!(3).abs!
-
-  hist.increment(x, y)
-
-#  p scale
-#  p hist
-#  p hist.out_of_table
-#  p hist[:i,nil].sum
-
-  CA.gnuplot { |g|
-#    g.image(hist, :title => "2D histogram test")
-    g.grid3d(
-      [scale, scale, hist],
-      :with => "dots",
-      :title => "2D histogram test")
-  }
-
-end

data/lib/carray/math/recurrence.rb

@@ -1,93 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  carray/math/recurrence.rb
-#
-#  This file is part of Ruby/CArray extension library.
-#
-#  Copyright (C) 2005-2020 Hiroki Motoyoshi
-#
-# ----------------------------------------------------------------------------
-
-require 'carray'
-
-class CARecurrence < CAObject # :nodoc:
-
-  #
-  # init should be a hash like,
-  #  * [0] => 1, [1] => 1 ...
-  #  * [0,0] => 1, [0,1] => 2 ...
-  #
-
-  def initialize (data, init = {}, &block)
-    @value = data
-    @flag = CArray.boolean(*data.dim)
-    @block = block
-    init.each do |idx, val|
-      @value[*idx] = val
-      @flag[*idx] = 1
-    end
-    super(data.data_type, data.dim, :bytes => data.bytes, :read_only => true)
-  end
-
-  def reset (init = {})
-    @flag[] = 0
-    init.each do |idx, val|
-      @value[*idx] = val
-      @flag[*idx] = 1
-    end
-  end
-
-  private
-
-  def fetch_addr (addr)
-    if @flag[addr] == 1
-      return @value[addr]
-    else
-      idx = addr2index(addr)
-      val = @block[@value, *idx]
-      @value[addr] = val
-      @flag[idx] = 1
-      return val
-    end
-  end
-
-  def copy_data (data)
-    each_addr do |addr|
-      fetch_addr(addr)
-    end
-    data[] = @value
-  end
-
-end
-
-class CArray
-
-  def recurrence! (init = {}, &block)
-    lazy = CARecurrence.new(self, init, &block)
-    CArray.attach(lazy) {}
-    return self
-  end
-
-  def recurrence (*argv, &block)
-    return self.template.recurrence!(*argv, &block)
-  end
-
-end
-
-if __FILE__ == $0
-
-  x = 0.5
-  leg = CArray.float(24).recurrence!([0]=>1, [1]=>x) { |a, i|
-    w  = x * a[i-1]
-    wy = w - a[i-2]
-    wy+w-wy/i
-  }
-
-  p leg
-
-  CA.gnuplot { |g|
-    g.plot2d([leg.address, leg, nil, "linespoints"])
-  }
-
-end
-

data/lib/carray/object/ca_obj_iterator.rb

@@ -1,50 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  carray/object/ca_obj_iterator.rb
-#
-#  This file is part of Ruby/CArray extension library.
-#
-#  Copyright (C) 2005-2020 Hiroki Motoyoshi
-#
-# ----------------------------------------------------------------------------
-
-class CAIteratorArray < CAObject # :nodoc:
-
-  def initialize (it)
-    @it = it
-    super(CA_OBJECT, @it.dim)
-  end
-
-  private
-
-  def fetch_index (idx)
-    return @it.kernel_at_index(idx)
-  end
-
-  def store_index (idx, val)
-    @it.kernel_at_index(idx)[] = val
-  end
-
-  def copy_data (data)
-    data.each_index do |*idx|
-      data[*idx] = @it.kernel_at_index(idx)
-    end
-  end
-
-  def sync_data (data)
-    tmpl = @it.reference.template
-    data.each_index do |*idx|
-      @it.kernel_at_index(idx, tmpl)[] = data[*idx]
-    end
-    @it.reference[] = tmpl
-  end
-
-  def fill_data (data)
-    tmpl = @it.reference.template
-    CArray.each_index(*@it.dim) do |*idx|
-      @it.kernel_at_index(idx, tmpl)[] = data
-    end
-    @it.reference[] = tmpl
-  end
-
-end

data/lib/carray/object/ca_obj_link.rb

@@ -1,50 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  carray/object/ca_obj_link.rb
-#
-#  This file is part of Ruby/CArray extension library.
-#
-#  Copyright (C) 2005-2020 Hiroki Motoyoshi
-#
-# ----------------------------------------------------------------------------
-
-require "carray"
-
-class CALink < CAObject # :nodoc: 
-
-  def initialize (*argv, &block)
-    @evaluator = block
-    @argv      = argv
-    @args      = argv.map{|v| CScalar.new(v.data_type) }
-    val = @evaluator.call(*argv)
-    unless val.is_a?(CArray)
-      val = CA_OBJECT(val)      
-    end
-    super(val.data_type, val.dim, :bytes=>val.bytes, :read_only=>true)
-  end
-
-  private
-
-  def fetch_addr (addr)
-    @argv.each_with_index do |v, i|
-      case v
-      when CScalar
-        @args[i][] = v[]
-      when CArray
-        @args[i][] = v[addr]
-      else
-        @args[i][] = v
-      end
-    end
-    return @evaluator.call(*@args)[0]
-  end
-
-  def copy_data (data)
-    data[] = @evaluator.call(*@argv)
-  end
-
-  def create_mask
-  end
-
-end
-