class Khiva::Array

Constants

TYPES
TYPE_FORMAT

TODO support complex

Public Class Methods

finalize(ptr) click to toggle source
# File lib/khiva/array.rb, line 134
def self.finalize(ptr)
  # must use proc instead of stabby lambda
  proc { FFI.call(:delete_array, ptr) }
end
new(obj, type: nil) click to toggle source
# File lib/khiva/array.rb, line 20
def initialize(obj, type: nil)
  if obj.is_a?(Fiddle::Pointer)
    @ptr = obj
  else
    # TODO make more performant for Numo
    obj = obj.to_a
    dims = []
    o = obj
    4.times do
      break unless o.is_a?(::Array)
      dims << o.size
      o = o.first
    end
    dims.reverse!

    flat_obj = obj.flatten(dims.size)

    # TODO check each dimension
    expected_size = dims.inject(1, &:*)
    raise Error, "Unexpected size" if flat_obj.size != expected_size

    # TODO check integer range
    type ||= flat_obj.all? { |v| v.is_a?(Integer) } ? :s64 : :f64

    data = Fiddle::Pointer[flat_obj.pack("#{TYPE_FORMAT[type]}*")]
    ndims = dims.size
    dims = Fiddle::Pointer[dims.pack("q!*")]
    result = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)

    FFI.call(:create_array, data, ndims, dims, result, TYPES.index(type))
    @ptr = result
  end

  ObjectSpace.define_finalizer(self, self.class.finalize(@ptr))
end

Public Instance Methods

clone()
Alias for: copy
copy() click to toggle source
# File lib/khiva/array.rb, line 126
def copy
  result = Utils.create_ptr
  FFI.call(:copy, @ptr, result)
  self.class.new(result)
end
Also aliased as: dup, clone
dims() click to toggle source
# File lib/khiva/array.rb, line 95
def dims
  dims = Fiddle::Pointer.malloc(Fiddle::SIZEOF_LONG_LONG * 4)
  FFI.call(:get_dims, @ptr, dims)
  dims.to_s(dims.size).unpack("q!*")
end
display() click to toggle source
# File lib/khiva/array.rb, line 56
def display
  FFI.call(:display, @ptr)
end
dup()
Alias for: copy
element_size() click to toggle source
# File lib/khiva/array.rb, line 111
def element_size
  case type
  when :b8, :u8
    1
  when :s16, :u16
    2
  when :f32, :c32, :s32, :u32
    4
  when :f64, :c64, :s64, :u64
    8
  else
    raise Error, "Unknown type: #{type}"
  end
end
to_a() click to toggle source
# File lib/khiva/array.rb, line 82
def to_a
  d = dims
  d.pop while d.last == 1 && d.size > 1
  d.reverse!

  elements = dims.inject(1, &:*)
  data = Fiddle::Pointer.malloc(elements * element_size)
  FFI.call(:get_data, @ptr, data)
  result = data.to_s(data.size).unpack("#{TYPE_FORMAT[type]}*")
  result.map! { |r| r > 0 ? true : false } if type == :b8
  Utils.reshape(result, d)
end
to_ptr() click to toggle source
# File lib/khiva/array.rb, line 107
def to_ptr
  @ptr
end
type() click to toggle source
# File lib/khiva/array.rb, line 101
def type
  type = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
  FFI.call(:get_type, @ptr, type)
  TYPES[type.to_s(type.size).unpack1("i")]
end