ruby-gr 0.0.5 → 0.0.6

data/lib/gr3/ffi.rb

@@ -1,95 +1,131 @@
 # frozen_string_literal: true
 
-require 'ffi'
+require 'fiddle/import'
 
 module GR3
   # FFI Wrapper module for GR3
   module FFI
-    extend ::FFI::Library
+    extend Fiddle::Importer
 
     begin
-      ffi_lib GR3.ffi_lib
+      dlload GR3.ffi_lib
     rescue LoadError
       raise LoadError, 'Could not find GR Framework'
     end
 
-    extend GRCommons::AttachFunction
+    extend GRCommons::Extern
 
     # https://github.com/sciapp/gr/blob/master/lib/gr3/gr3.h
 
-    attach_function :gr3_init, %i[int], :int
-    attach_function :gr3_free, %i[pointer], :void
-    attach_function :gr3_terminate, %i[], :void
-    attach_function :gr3_geterror, %i[int pointer pointer], :int
-    attach_function :gr3_getrenderpathstring, %i[], :string
-    attach_function :gr3_geterrorstring, %i[int], :string
-    # callback :gr3_log_func, %i[string], :void
-    # attach_function :gr3_setlogcallback, %i[:gr3_log_func], :void
-    attach_function :gr3_clear, %i[], :int
-    attach_function :gr3_usecurrentframebuffer, %i[], :void
-    attach_function :gr3_useframebuffer, %i[uint], :void
-    attach_function :gr3_setquality, %i[int], :int
-    attach_function :gr3_getimage, %i[int int int pointer], :int
-    attach_function :gr3_export, %i[pointer int int], :int
-    attach_function :gr3_drawimage, %i[float float float float int int int], :int
-    attach_function :gr3_createmesh_nocopy, %i[pointer int pointer pointer pointer], :int
-    attach_function :gr3_createmesh, %i[pointer int pointer pointer pointer], :int
-    attach_function :gr3_createindexedmesh_nocopy, %i[pointer int pointer pointer pointer int pointer], :int
-    attach_function :gr3_createindexedmesh, %i[pointer int pointer pointer pointer int pointer], :int
-    attach_function :gr3_drawmesh, %i[int int pointer pointer pointer pointer pointer], :void
-    attach_function :gr3_deletemesh, %i[int], :void
-    attach_function :gr3_cameralookat, %i[float float float float float float float float float], :void
-    attach_function :gr3_setcameraprojectionparameters, %i[float float float], :int
-    attach_function :gr3_getcameraprojectionparameters, %i[pointer pointer pointer], :int
-    attach_function :gr3_setlightdirection, %i[float float float], :void
-    attach_function :gr3_setbackgroundcolor, %i[float float float float], :void
-    # getbackgroundcolor not implemented
-    attach_function :gr3_createheightmapmesh, %i[pointer int int], :void
-    attach_function :gr3_drawheightmap, %i[pointer int int pointer pointer], :void
-    attach_function :gr3_drawconemesh, %i[int pointer pointer pointer pointer pointer], :void
-    attach_function :gr3_drawcylindermesh, %i[int pointer pointer pointer pointer pointer], :void
-    attach_function :gr3_drawspheremesh, %i[int pointer pointer pointer], :void
-    attach_function :gr3_drawcubemesh, %i[int pointer pointer pointer pointer pointer], :void
-    attach_function :gr3_setobjectid, %i[int], :void
-    attach_function :gr3_selectid, %i[int int int int pointer], :int
-    attach_function :gr3_getviewmatrix, %i[pointer], :void
-    attach_function :gr3_setviewmatrix, %i[pointer], :void
-    attach_function :gr3_getprojectiontype, %i[], :int
-    attach_function :gr3_setprojectiontype, %i[int], :void
-    # attach_function :gr3_triangulate,
-    # %i[pointer ushort uint uint uint uint uint uint double double double double double double pointer], :void
-    # attach_function :gr3_triangulateindexed,
-    # %i[pointer ushort uint uint uint uint uint uint double double double double double double pointer pointer pointer pointer poiter], :void
-    attach_function :gr3_createisosurfacemesh,
-                    %i[pointer pointer ushort uint uint uint uint uint uint double double double double double double],
-                    :int
-    attach_function :gr3_createsurfacemesh, %i[pointer int int pointer pointer pointer int], :int
-    attach_function :gr3_drawmesh_grlike, %i[int int pointer pointer pointer pointer pointer], :void
-    attach_function :gr3_drawsurface, %i[int], :void
-    attach_function :gr3_surface, %i[int int pointer pointer pointer int], :void
-    attach_function :gr3_drawtubemesh, %i[int pointer pointer pointer int int], :int
-    attach_function :gr3_createtubemesh, %i[pointer int pointer pointer pointer int int], :int
-    attach_function :gr3_drawspins, %i[int pointer pointer pointer float float float float], :void
-    attach_function :gr3_drawmolecule, %i[int pointer pointer pointer float pointer float], :void
-    attach_function :gr3_createxslicemesh,
-                    %i[pointer pointer uint uint uint uint uint uint uint double double double double double double],
-                    :void
-    attach_function :gr3_createyslicemesh,
-                    %i[pointer pointer uint uint uint uint uint uint uint double double double double double double],
-                    :void
-    attach_function :gr3_createzslicemesh,
-                    %i[pointer pointer uint uint uint uint uint uint uint double double double double double double],
-                    :void
-    attach_function :gr3_drawxslicemesh,
-                    %i[pointer uint uint uint uint uint uint uint double double double double double double],
-                    :void
-    attach_function :gr3_drawyslicemesh,
-                    %i[pointer uint uint uint uint uint uint uint double double double double double double],
-                    :void
-    attach_function :gr3_drawzslicemesh,
-                    %i[pointer uint uint uint uint uint uint uint double double double double double double],
-                    :void
-    # attach_function :gr3_drawtrianglesurface, %i[int pointer], :void
-    attach_function :gr_volume, %i[int int int pointer int pointer pointer], :void
+    extern 'int gr3_init(int *attrib_list)'
+    extern 'void gr3_free(void *pointer)'
+    extern 'void gr3_terminate(void)'
+    extern 'int gr3_geterror(int clear, int *line, const char **file)'
+    extern 'const char *gr3_getrenderpathstring(void)'
+    extern 'const char *gr3_geterrorstring(int error)'
+    # extern 'void gr3_setlogcallback(void (*gr3_log_func)(const char *log_message))'
+    extern 'int gr3_clear(void)'
+    extern 'void gr3_usecurrentframebuffer()'
+    extern 'void gr3_useframebuffer(unsigned int framebuffer)'
+    extern 'int gr3_setquality(int quality)'
+    extern 'int gr3_getimage(int width, int height, int use_alpha, char *pixels)'
+    extern 'int gr3_export(const char *filename, int width, int height)'
+    extern 'int gr3_drawimage(float xmin, float xmax, float ymin, float ymax, ' \
+           'int width, int height, int drawable_type)'
+    extern 'int gr3_createmesh_nocopy(int *mesh, int n, ' \
+           'float *vertices, float *normals, float *colors)'
+    extern 'int gr3_createmesh(int *mesh, int n, ' \
+           'const float *vertices, const float *normals, const float *colors)'
+    extern 'int gr3_createindexedmesh_nocopy(int *mesh, int number_of_vertices, ' \
+           'float *vertices, float *normals, float *colors, int number_of_indices, int *indices)'
+    extern 'int gr3_createindexedmesh(int *mesh, int number_of_vertices, ' \
+           'const float *vertices, const float *normals, const float *colors, ' \
+           'int number_of_indices, const int *indices)'
+    extern 'void gr3_drawmesh(int mesh, int n, ' \
+           'const float *positions, const float *directions, const float *ups, ' \
+           'const float *colors, const float *scales)'
+    extern 'void gr3_deletemesh(int mesh)'
+    extern 'void gr3_cameralookat(float camera_x, float camera_y, float camera_z, ' \
+           'float center_x, float center_y, float center_z, ' \
+           'float up_x, float up_y, float up_z)'
+    extern 'int gr3_setcameraprojectionparameters(float vertical_field_of_view, ' \
+           'float zNear, float zFar)'
+    extern 'int gr3_getcameraprojectionparameters(float *vfov, float *znear, float *zfar)'
+    extern 'void gr3_setlightdirection(float x, float y, float z)'
+    extern 'void gr3_setbackgroundcolor(float red, float green, float blue, float alpha)'
+    extern 'int gr3_createheightmapmesh(const float *heightmap, int num_columns, int num_rows)'
+    extern 'void gr3_drawheightmap(const float *heightmap, ' \
+           'int num_columns, int num_rows, const float *positions, const float *scales)'
+    extern 'void gr3_drawconemesh(int n, const float *positions, const float *directions, ' \
+           'const float *colors, const float *radii, const float *lengths)'
+    extern 'void gr3_drawcylindermesh(int n, const float *positions, const float *directions, ' \
+           'const float *colors, const float *radii, const float *lengths)'
+    extern 'void gr3_drawspheremesh(int n, const float *positions, ' \
+           'const float *colors, const float *radii)'
+    extern 'void gr3_drawcubemesh(int n, ' \
+           'const float *positions, const float *directions, const float *ups, ' \
+           'const float *colors, const float *scales)'
+    extern 'void gr3_setobjectid(int id)'
+    extern 'int gr3_selectid(int x, int y, int width, int height, int *selection_id)'
+    extern 'void gr3_getviewmatrix(float *m)'
+    extern 'void gr3_setviewmatrix(const float *m)'
+    extern 'int gr3_getprojectiontype(void)'
+    extern 'void gr3_setprojectiontype(int type)'
+    # extern 'unsigned int gr3_triangulate(const unsigned short *data, unsigned short isolevel, unsigned int dim_x, unsigned int dim_y, unsigned int dim_z, unsigned int stride_x, unsigned int stride_y, unsigned int stride_z, double step_x, double step_y, double step_z, double offset_x, double offset_y, double offset_z, gr3_triangle_t **triangles_p)'
+    # extern 'void gr3_triangulateindexed(const unsigned short *data, unsigned short isolevel, unsigned int dim_x, unsigned int dim_y, unsigned int dim_z, unsigned int stride_x, unsigned int stride_y, unsigned int stride_z, double step_x, double step_y, double step_z, double offset_x, double offset_y, double offset_z, unsigned int *num_vertices, gr3_coord_t **vertices, gr3_coord_t **normals, unsigned int *num_indices, unsigned int **indices)'
+    extern 'int gr3_createisosurfacemesh(int *mesh, unsigned short *data, ' \
+           'unsigned short isolevel, unsigned int dim_x, unsigned int dim_y, unsigned int dim_z, ' \
+           'unsigned int stride_x, unsigned int stride_y, unsigned int stride_z, ' \
+           'double step_x, double step_y, double step_z, ' \
+           'double offset_x, double offset_y, double offset_z)'
+    extern 'int gr3_createsurfacemesh(int *mesh, int nx, int ny, ' \
+           'float *px, float *py, float *pz, int option)'
+    extern 'void gr3_drawmesh_grlike(int mesh, int n, ' \
+           'const float *positions, const float *directions, const float *ups, ' \
+           'const float *colors, const float *scales)'
+    extern 'void gr3_drawsurface(int mesh)'
+    extern 'void gr3_surface(int nx, int ny, float *px, float *py, float *pz, int option)'
+    extern 'int gr3_drawtubemesh(int n, float *points, float *colors, float *radii, ' \
+           'int num_steps, int num_segments)'
+    extern 'int gr3_createtubemesh(int *mesh, int n, ' \
+           'const float *points, const float *colors, const float *radii, ' \
+           'int num_steps, int num_segments)'
+    extern 'void gr3_drawspins(int n, const float *positions, const float *directions, const float *colors, ' \
+           'float cone_radius, float cylinder_radius, float cone_height, float cylinder_height)'
+    extern 'void gr3_drawmolecule(int n, const float *positions, const float *colors, const float *radii, ' \
+           'float bond_radius, const float bond_color[3], float bond_delta)'
+    extern 'void gr3_createxslicemesh(int *mesh, const unsigned short *data, ' \
+           'unsigned int ix, unsigned int dim_x, unsigned int dim_y, unsigned int dim_z, ' \
+           'unsigned int stride_x, unsigned int stride_y, unsigned int stride_z, ' \
+           'double step_x, double step_y, double step_z, ' \
+           'double offset_x, double offset_y, double offset_z)'
+    extern 'void gr3_createyslicemesh(int *mesh, const unsigned short *data, ' \
+           'unsigned int iy, unsigned int dim_x, unsigned int dim_y, unsigned int dim_z, ' \
+           'unsigned int stride_x, unsigned int stride_y, unsigned int stride_z, ' \
+           'double step_x, double step_y, double step_z, ' \
+           'double offset_x, double offset_y, double offset_z)'
+    extern 'void gr3_createzslicemesh(int *mesh, const unsigned short *data, ' \
+           'unsigned int iz, unsigned int dim_x, unsigned int dim_y, unsigned int dim_z, ' \
+           'unsigned int stride_x, unsigned int stride_y, unsigned int stride_z, ' \
+           'double step_x, double step_y, double step_z, ' \
+           'double offset_x, double offset_y, double offset_z)'
+    extern 'void gr3_drawxslicemesh(const unsigned short *data, unsigned int ix,' \
+           'unsigned int dim_x, unsigned int dim_y, unsigned int dim_z, ' \
+           'unsigned int stride_x, unsigned int stride_y, unsigned int stride_z, ' \
+           'double step_x, double step_y, double step_z, ' \
+           'double offset_x, double offset_y, double offset_z)'
+    extern 'void gr3_drawyslicemesh(const unsigned short *data, unsigned int iy, ' \
+           'unsigned int dim_x, unsigned int dim_y, unsigned int dim_z, ' \
+           'unsigned int stride_x, unsigned int stride_y, unsigned int stride_z, ' \
+           'double step_x, double step_y, double step_z, ' \
+           'double offset_x, double offset_y, double offset_z)'
+    extern 'void gr3_drawzslicemesh(const unsigned short *data, unsigned int iz, ' \
+           'unsigned int dim_x, unsigned int dim_y, unsigned int dim_z, ' \
+           'unsigned int stride_x, unsigned int stride_y, unsigned int stride_z, ' \
+           'double step_x, double step_y, double step_z, ' \
+           'double offset_x, double offset_y, double offset_z)'
+    # extern 'void gr3_drawtrianglesurface(int n, const float *triangles)'
+    extern 'void gr_volume(int nx, int ny, int nz, double *data, ' \
+           'int algorithm, double *dmin_ptr, double *dmax_ptr)'
   end
 end

data/lib/gr3/gr3base.rb

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
 module GR3
+  # This module automatically converts Ruby arrays and Numo::Narray into pointers.
   module GR3Base
     extend GRCommons::DefineMethods
     define_ffi_methods(FFI,
                        prefix: 'gr3_',
                        default_type: :float)
+    # workaround for `gr_volume`
+    define_ffi_methods(FFI,
+                       prefix: 'gr_',
+                       default_type: :double)
   end
   private_constant :GR3Base
 

data/lib/gr_commons.rb

@@ -4,7 +4,7 @@
 module GRCommons
 end
 
-require 'gr_commons/attach_function'
+require 'gr_commons/extern'
 require 'gr_commons/define_methods'
 require 'gr_commons/gr_common_utils'
 require 'gr_commons/jupyter_support'

data/lib/gr_commons/define_methods.rb

@@ -10,12 +10,14 @@ module GRCommons
         # delete_prefix (Ruby >= 2.5)
         method_name = method.to_s.sub(/^#{prefix}/, '')
 
+        # FIXME: Refactoring required
+
         define_method(method_name) do |*args|
           args.map! do |arg|
             case arg
             when Array
               send(default_type, arg)
-            when ->(x) { narray? x }
+            when ->(x) { defined?(Numo::NArray) && x.is_a?(Numo::NArray) }
               send(default_type, arg)
             else
               arg

data/lib/gr_commons/extern.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module GRCommons
+  # This module records the names of the methods defined by Fiddle::Importer.
+  module Extern
+    attr_reader :ffi_methods
+
+    # Remember added method name
+    def extern(*args)
+      @ffi_methods ||= []
+      func = super(*args)
+      @ffi_methods << func.name
+      func
+    end
+  end
+end

data/lib/gr_commons/fiddley.rb

@@ -0,0 +1,419 @@
+# frozen_string_literal: true
+
+# Fiddley v0.0.8
+# https://github.com/unak/fiddley
+#
+# Copyright (c) 2017 NAKAMURA Usaku usa@garbagecollect.jp
+#
+# Released under the 2-Clause BSD License.
+
+# NOTE: kojix2 added, removed, and modified several methods.
+
+require 'fiddle/import'
+
+module GRCommons
+  # Ruby-FFI compatible API layer for Fiddle.
+  module Fiddley
+    # NOTE: GR.rb supports 2.4 +. Unpack 1 does not work under 2.3.
+
+    module Utils
+      # assumes short = 16bit, int = 32bit, long long = 64bit
+      SIZET_FORMAT = Fiddle::SIZEOF_VOIDP == Fiddle::SIZEOF_LONG ? 'l!' : 'q'
+      SIZET_TYPE = Fiddle::SIZEOF_VOIDP == Fiddle::SIZEOF_LONG ? 'unsigned long' : 'unsigned long long'
+
+      module_function
+
+      def type2size(type)
+        case type
+        when :char, :uchar, :int8, :uint8
+          Fiddle::SIZEOF_CHAR
+        when :short, :ushort, :int16, :uint16
+          Fiddle::SIZEOF_SHORT
+        when :int, :uint, :int32, :uint32, :bool
+          Fiddle::SIZEOF_INT
+        when :long, :ulong
+          Fiddle::SIZEOF_LONG
+        when :int64, :uint64, :long_long, :ulong_long
+          Fiddle::SIZEOF_LONG_LONG
+        when :float
+          Fiddle::SIZEOF_FLOAT
+        when :double
+          Fiddle::SIZEOF_DOUBLE
+        when :size_t
+          Fiddle::SIZEOF_SIZE_T
+        when :string, :pointer
+          Fiddle::SIZEOF_VOIDP
+        else
+          raise "unknown type #{type}"
+        end
+      end
+
+      # `type2offset_size` is not used in GR.rb, so deleted.
+
+      # `str2value` is not used in GR.rb, so deleted.
+
+      # added
+      def str2array(type, str)
+        case type
+        when :char, :int8
+          str.unpack('c*')
+        when :uchar, :uint8
+          str.unpack('C*')
+        when :short, :int16
+          str.unpack('s*')
+        when :ushort, :uint16
+          str.unpack('S*')
+        when :int32
+          str.unpack('l*')
+        when :uint32
+          str.unpack('L*')
+        when :int
+          str.unpack('i!*')
+        when :uint
+          str.unpack('I!*')
+        when :bool
+          str.unpack('i!*') != 0
+        when :long
+          str.unpack('l!*')
+        when :ulong
+          str.unpack('L!*')
+        when :long_long, :int64
+          str.unpack('q*')
+        when :ulong_long, :uint64
+          str.unpack('Q*')
+        when :size_t
+          str.unpack(SIZET_FORMAT)
+        when :float
+          str.unpack('f*')
+        when :double
+          str.unpack('d*')
+        when :string, :pointer
+          str.unpack('p*')
+        else
+          raise "unknown type #{type}"
+        end
+      end
+
+      # `value2str` is not used in GR.rb, so deleted.
+
+      # added
+      def array2str(type, arr)
+        case type
+        when :char, :int8
+          arr.pack('c*')
+        when :uchar, :uint8
+          arr.pack('C*')
+        when :short, :int16
+          arr.pack('s*')
+        when :ushort, :uint16
+          arr.pack('S*')
+        when :int32
+          arr.pack('l*')
+        when :uint32
+          arr.pack('L*')
+        when :int
+          arr.pack('i!*')
+        when :uint
+          arr.pack('I!*')
+        when :bool
+          [arr ? 1 : 0].pack('i!*')
+        when :long
+          arr.pack('l!*')
+        when :ulong
+          arr.pack('L!*')
+        when :long_long, :int64
+          arr.pack('q*')
+        when :ulong_long, :uint64
+          arr.pack('Q*')
+        when :size_t
+          arr.pack(SIZET_FORMAT)
+        when :float
+          arr.pack('f*')
+        when :double
+          arr.pack('d*')
+        when :string, :pointer
+          arr.pack('p*')
+        else
+          raise "unknown type #{type}"
+        end
+      end
+
+      # `type2str` is not used in GR.rb, so deleted.
+
+      def type2type(type)
+        case type
+        when :char, :int8
+          Fiddle::TYPE_CHAR
+        when :uchar, :uint8
+          -Fiddle::TYPE_CHAR
+        when :short, :int16
+          Fiddle::TYPE_SHORT
+        when :ushort, :uint16
+          -Fiddle::TYPE_SHORT
+        when :int, :int32
+          Fiddle::TYPE_INT
+        when :uint, :uint32
+          -Fiddle::TYPE_INT
+        when :bool
+          Fiddle::TYPE_INT
+        when :long
+          Fiddle::TYPE_LONG
+        when :ulong
+          -Fiddle::TYPE_LONG
+        when :long_long, :int64
+          Fiddle::TYPE_LONG_LONG
+        when :ulong_long, :uint64
+          -Fiddle::TYPE_LONG_LONG
+        when :float
+          Fiddle::TYPE_FLOAT
+        when :double
+          Fiddle::TYPE_DOUBLE
+        when :size_t
+          Fiddle::TYPE_SIZE_T
+        when :string, :pointer
+          Fiddle::TYPE_VOIDP
+        when :void
+          Fiddle::TYPE_VOID
+        else
+          raise "unknown type #{type}"
+        end
+      end
+    end
+
+    class MemoryPointer
+      using Fiddley::RefineStringUnpack1 if defined?(Fiddley::RefineStringUnpack1)
+
+      include Fiddley::Utils
+
+      def initialize(type, num = 1, _clear = true)
+        if num.is_a?(Fiddle::Pointer)
+          @ptr = num
+          @size = @ptr.size
+        else
+          @size = type2size(type) * num
+          @ptr = Fiddle::Pointer.malloc(@size)
+        end
+      end
+
+      attr_reader :size
+
+      def to_ptr
+        @ptr
+      end
+
+      { 8 => 'c', 16 => 's', 32 => 'l', 64 => 'q' }.each do |bits, form|
+        bytes = bits / 8
+
+        define_method("put_int#{bits}") do |offset, val|
+          @ptr[offset, bytes] = [val].pack(form)
+        end
+
+        define_method("write_int#{bits}") do |val|
+          __send__("put_int#{bits}", 0, val)
+        end
+
+        define_method("put_array_of_int#{bits}") do |offset, ary|
+          put_bytes(offset, ary.pack(form + '*'))
+        end
+
+        define_method("write_array_of_int#{bits}") do |ary|
+          __send__("put_array_of_int#{bits}", 0, ary)
+        end
+
+        define_method("get_int#{bits}") do |offset|
+          @ptr[offset, bytes].unpack1(form)
+        end
+
+        define_method("read_int#{bits}") do
+          __send__("get_int#{bits}", 0)
+        end
+
+        define_method("get_array_of_int#{bits}") do |offset, num|
+          @ptr[offset, bytes * num].unpack(form + '*')
+        end
+
+        define_method("read_array_of_int#{bits}") do |num|
+          __send__("get_array_of_int#{bits}", 0, num)
+        end
+
+        form2 = form.upcase
+
+        define_method("put_uint#{bits}") do |offset, val|
+          @ptr[offset, bytes] = [val].pack(form2)
+        end
+
+        define_method("write_uint#{bits}") do |val|
+          __send__("put_uint#{bits}", 0, val)
+        end
+
+        define_method("put_array_of_uint#{bits}") do |offset, ary|
+          put_bytes(offset, ary.pack(form2 + '*'))
+        end
+
+        define_method("write_array_of_uint#{bits}") do |ary|
+          __send__("put_array_of_uint#{bits}", 0, ary)
+        end
+
+        define_method("get_uint#{bits}") do |offset|
+          @ptr[offset, bytes].unpack1(form2)
+        end
+
+        define_method("read_uint#{bits}") do
+          __send__("get_uint#{bits}", 0)
+        end
+
+        define_method("get_array_of_uint#{bits}") do |offset, num|
+          @ptr[offset, bytes * num].unpack(form2 + '*')
+        end
+
+        define_method("read_array_of_uint#{bits}") do |num|
+          __send__("get_array_of_uint#{bits}", 0, num)
+        end
+      end
+
+      # added
+      define_method('put_double') do |offset, val|
+        @ptr[offset, 8] = [val].pack('d')
+      end
+
+      # added
+      define_method('put_float') do |offset, val|
+        @ptr[offset, 4] = [val].pack('f')
+      end
+
+      # added
+      define_method('write_double') do |val|
+        __send__('put_double', 0, val)
+      end
+
+      # added
+      define_method('write_float') do |val|
+        __send__('put_float', 0, val)
+      end
+
+      # added
+      define_method('put_array_of_double') do |offset, ary|
+        put_bytes(offset, ary.pack('d*'))
+      end
+
+      # added
+      define_method('write_array_of_double') do |ary|
+        __send__('put_array_of_double', 0, ary)
+      end
+
+      # added
+      define_method('put_array_of_float') do |offset, ary|
+        put_bytes(offset, ary.pack('f*'))
+      end
+
+      # added
+      define_method('write_array_of_float') do |ary|
+        __send__('put_array_of_float', 0, ary)
+      end
+
+      # added
+      define_method('get_double') do |offset|
+        @ptr[offset, 8].unpack1('d')
+      end
+
+      # added
+      define_method('read_double') do
+        __send__('get_double', 0)
+      end
+
+      # added
+      define_method('get_float') do |offset|
+        @ptr[offset, 4].unpack1('f')
+      end
+
+      # added
+      define_method('read_float') do
+        __send__('get_double', 0)
+      end
+
+      # added
+      define_method('get_array_of_double') do |offset, num|
+        @ptr[offset, 8 * num].unpack('d' + '*')
+      end
+
+      # added
+      define_method('get_array_of_float') do |offset, num|
+        @ptr[offset, 4 * num].unpack('f' + '*')
+      end
+
+      # added
+      define_method('read_array_of_double') do |num|
+        __send__('get_array_of_double', 0, num)
+      end
+
+      # added
+      define_method('read_array_of_float') do |num|
+        __send__('get_array_of_float', 0, num)
+      end
+
+      def put_bytes(offset, str, idx = 0, len = str.bytesize - idx)
+        @ptr[offset, len] = str[idx, len]
+      end
+
+      def write_bytes(str, idx = 0, len = nil)
+        put_bytes(0, str, idx, len)
+      end
+
+      def get_bytes(offset, len)
+        @ptr[offset, len]
+      end
+
+      def read_bytes(len)
+        get_bytes(0, len)
+      end
+
+      def put_string(offset, str)
+        @ptr[offset, str.bytesize] = str
+      end
+
+      def write_string(str, len = nil)
+        put_string(0, len ? str[0, len] : str)
+      end
+
+      def write_string_length(str, len)
+        put_string(0, str[0, len])
+      end
+
+      def get_string(offset, len = nil)
+        @ptr[offset, len || @size - offset]
+      end
+
+      def read_string(len = nil)
+        get_string(0, len)
+      end
+
+      # added
+      # NOTE: Return Fiddle::Pointer. Not MemoryPointer.
+      def read_pointer
+        to_ptr.ptr
+      end
+
+      alias put_int put_int32
+      alias write_int write_int32
+      alias get_int get_int32
+      alias read_int read_int32
+      alias write_array_of_int write_array_of_int32 # added
+      alias read_array_of_int read_array_of_int32 # added
+
+      alias put_uint put_uint32
+      alias write_uint write_uint32
+      alias get_uint get_uint32
+      alias read_uint read_uint32
+      alias write_array_of_uint write_array_of_uint32 # added
+      alias read_array_of_uint read_array_of_uint32 # added
+    end
+
+    class Function < Fiddle::Closure::BlockCaller
+      include Fiddley::Utils
+
+      def initialize(ret, params, &blk)
+        super(type2type(ret), params.map { |e| type2type(e) }, &blk)
+      end
+    end
+  end
+end