carray 1.1.4 → 1.1.5

data/lib/carray/mkmf.rb

@@ -0,0 +1,145 @@
+# ----------------------------------------------------------------------------
+#
+#  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
+#
+# ----------------------------------------------------------------------------
+
+require 'mkmf'
+
+def have_carray 
+  begin
+    require 'carray'
+  rescue LoadError
+    abort "Ruby/CArray is not installed"
+  end
+  dir_config("carray", $sitearchdir, $sitearchdir)
+  if defined? Gem
+    if Gem::VERSION >= "1.7.0"
+      begin
+        Gem::Specification.find_all_by_name("carray").each do |spec|
+          dir = spec.full_gem_path
+          dir_config("carray", dir, dir)      
+        end
+      rescue Gem::LoadError
+      end
+    else
+      Gem.all_load_paths.grep(/narray/).each do |dir|
+        dir_config("carray", dir, dir)      
+      end
+    end
+  end
+  status = true
+  status &= have_header("carray.h")
+  if /cygwin|mingw/ =~ RUBY_PLATFORM
+    status &= have_library("carray")
+  end
+  status
+end
+
+def check_fortran
+
+  SRC_EXT << "f" << "f90" << "f95"
+
+  fortran = with_config("fortran", "gfortran")
+  fflags  = with_config("fflags", "")
+
+  case fortran
+  when /\Ag77/
+    libdir = File.dirname(`#{fortran} --print-file-name=libg2c.a`)
+    dir_config("g2c", possible_includes, [libdir]+possible_libs)
+    have_library("g2c")
+    fc = fortran
+    fflags << " -O2 -g "
+  when /\Agfortran/
+    libdir = File.dirname(`#{fortran} --print-file-name=libgfortran.a`)
+    dir_config("gfortran", possible_includes, [libdir]+possible_libs)
+    have_library("gfortran")
+    fc = fortran
+    fflags << " -O2 -g -fPIC "
+  when /\Aintel/, /\Aifort/, /\Aifc/
+    libdir = File.join(File.dirname(File.dirname(`which ifort`)), "lib")
+    dir_config("ifcore", possible_includes, [libdir]+possible_libs)
+    have_library("ifcore")
+    have_library("ifport")
+    have_library("imf")
+    have_library("irc")
+    have_library("svml")
+    have_library("unwind")
+    fc = "ifort"
+    fflags << " -O2 -fPIC "
+  when /\Afujitsu/, /\Afrt/
+    libdir = File.join(File.dirname(File.dirname(`which frt`)), "lib")
+    dir_config("fj9f6", nil, libdir)
+    $LIBS = " -lfj9i6 -lfj9f6"
+    fc = "frt"
+    fflags = " -O -fw "
+  else
+    puts "unknown fortran option <#{fortran}>"
+    exit(1)
+  end
+  at_exit {
+    if File.file?("Makefile")
+      makefile = File.read("Makefile")
+      unless makefile =~ /^FC=/
+        makefile.sub!(/^COPY =.*$/, 
+                      '\0' + "\n\n" +
+                      "FC=#{fc}\n" +
+                      "FFLAGS=#{fflags}\n")
+      end
+      open("Makefile", "w") { |io| io.write(makefile) }
+    end
+  }
+
+  return "--with-fortran='#{fortran}' --with-fflags='#{fflags}'"
+
+end
+
+def possible_prefix (*postfixes)
+  dirs = [
+    File.expand_path("~/usr"),   ### user's home / usr
+    File.expand_path("~/local"), ### user's home / local
+    File.expand_path("~"),       ### user's home
+    "/opt/local",                ### MacPorts
+    "/opt",                      ### UNIX 
+    "/sw/local",                 ### Mac Fink
+    "/sw/",                      ### Mac Fink
+    "/usr/X11R6",                ### UNIX X11
+    "/usr/local",                ### UNIX
+    "/usr",                      ### UNIX
+    "/"                          ### UNIX
+  ]
+  if postfixes
+    dirs = postfixes.inject(dirs) { |list, postfix|
+      list + dirs.map{|d| File.join(d, postfix) }
+    }
+  end 
+  return dirs.select{|d| File.directory?(d)}
+end
+
+POSSIBLE_PREFIX = possible_prefix()
+
+def possible_libs (*postfixes)
+  dirs = possible_prefix().map{|prefix| File.join(prefix, "lib") }
+  if postfixes
+    dirs = postfixes.inject(dirs) { |list, postfix|
+      list + dirs.map{|d| File.join(d, postfix) }
+    }
+  end 
+  return dirs.select{|d| File.directory?(d)}
+end
+
+def possible_includes (*postfixes)
+  dirs = possible_prefix().map{|prefix| File.join(prefix, "include") }
+  if postfixes
+    dirs = postfixes.inject(dirs) { |list, postfix|
+      list + dirs.map{|d| File.join(d, postfix) }
+    }
+  end 
+  return dirs.select{|d| File.directory?(d)}
+end

data/lib/carray/object/ca_obj_iterator.rb

@@ -0,0 +1,52 @@
+# ----------------------------------------------------------------------------
+#
+#  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
+#
+# ----------------------------------------------------------------------------
+
+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

@@ -0,0 +1,52 @@
+# ----------------------------------------------------------------------------
+#
+#  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
+#
+# ----------------------------------------------------------------------------
+
+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
+

data/lib/carray/object/ca_obj_pack.rb

@@ -0,0 +1,101 @@
+# ----------------------------------------------------------------------------
+#
+#  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
+#
+# ----------------------------------------------------------------------------
+
+#
+#
+# [ca1, ca2, ca3] => ca4
+#
+#
+#
+
+
+class CAPack < CAObject # :nodoc:
+
+  def initialize (list, options={})
+    @list   = list
+    @rank   = options[:rank]
+    unless @rank
+      @rank = list.map{|m| m.rank}.min
+    end
+    @names  = options[:names] || [nil]*@list.size
+    @dim    = guess_dim(list)
+    @struct = guess_struct(list)
+    super(@struct, @dim, :read_only=>true)
+    freeze
+  end
+
+  private
+
+  def fetch_index (idx)
+    out   = @struct.new
+    dummy = idx + [false]
+    @struct.members.each_with_index do |name, i|
+      out[name] = @list[i][*dummy]
+    end
+    return out
+  end
+
+  def copy_data (data)
+    data.fields.zip(@list).each do |mem, d|
+      mem[] = d
+    end
+  end
+
+  def guess_dim (list)
+    dim = nil
+    list.each do |mem|
+      case mem
+      when CArray
+        if mem.rank < @rank
+          raise "mem.rank < @rank"
+        else
+          newdim = mem.dim[0, @rank]
+        end
+        if dim
+          unless dim == newdim
+            raise "dim != newdim"
+          end
+        else
+          dim = newdim
+        end
+      end
+    end
+    return dim || [1]
+  end
+
+  def guess_struct (list)
+    st = CA.struct(:pack=>1) { |s|
+      list.each_with_index do |mem, i|
+        name = @names[i]
+        case mem
+        when CArray
+          if mem.rank == @rank
+            s.member mem.data_type, name, :bytes=>mem.bytes ### anonymous member
+          else
+            dummy = Array.new(@rank){0} + [false]
+            s.member mem[*dummy].to_ca, name                ### anonymous member
+          end
+        else
+          raise "invalid object for CAPack"
+        end
+      end
+    }
+    return st
+  end
+
+end
+
+class CArray
+  def self.pack (*argv)
+    return CAPack.new(argv)
+  end
+end

data/mkmath.rb

@@ -0,0 +1,731 @@
+# ----------------------------------------------------------------------------
+#
+#  mkmath.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
+#
+# ----------------------------------------------------------------------------
+
+require 'stringio'
+
+def monfunc (op, name, hash)
+  io = StringIO.new
+  io.puts
+  io.puts "/*----------------------- #{name} --------------------------*/"
+  hash.each do |types, expr0|
+    if not expr0
+      next
+    end
+    expr0.gsub!(/#/, '*p')
+    types.each do |type|
+      if type
+        expr = expr0.gsub(/<type>/, type)
+        omp_ok = ( type != "VALUE" ) ? 1 : 0
+        io.print %{
+static void
+ca_monop_#{name}_#{type} (int32_t n, boolean8_t *m, char *ptr1, int32_t i1, char *ptr2, int32_t i2)
+{
+  #{type} *q1 = (#{type} *) ptr1, *q2 = (#{type} *) ptr2;
+  #{type} *p1 = q1, *p2 = q2;
+  int32_t k;
+  if ( m ) {
+    boolean8_t *pm;
+    #if defined(_OPENMP) && #{omp_ok}
+    #pragma omp parallel for private(pm,p1,p2)
+    #endif
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        {
+          #{expr} 
+        }
+      }
+    }
+  }
+  else {
+    #if defined(_OPENMP) && #{omp_ok}
+    #pragma omp parallel for private(p1,p2)
+    #endif
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      {
+        #{expr}
+      }
+    }
+  }
+}
+}
+      end
+    end
+  end
+  io.puts
+  io.puts "ca_monop_func_t"
+  io.puts "ca_monop_#{name}[CA_NTYPE] = {"
+  ALL_TYPES.each_index do |i|
+    type = nil
+    hash.each do |types, expr|
+      if not expr
+        next
+      end
+      type ||= types[i]
+    end
+    if type
+      io.puts("  ca_monop_#{name}_#{type},")
+    else
+      io.puts("  ca_monop_not_implement,")
+    end
+  end
+  io.puts "};"
+  io.puts
+  if hash.has_key?(INT_TYPES) or hash.has_key?(ALL_TYPES)
+    io.print %{
+static VALUE rb_ca_#{name} (VALUE self)
+{ return rb_ca_call_monop(self, ca_monop_#{name}); }
+}
+  else
+    io.print %{
+static VALUE rb_ca_#{name} (VALUE self)
+{ 
+  if ( rb_ca_is_integer_type(self) ) {
+    self = rb_ca_wrap_readonly(self, INT2FIX(CA_FLOAT64));
+  }
+  return rb_ca_call_monop(self, ca_monop_#{name}); 
+}
+}
+  end
+  io.print %{
+static VALUE rb_ca_#{name}_bang (VALUE self)
+{ return rb_ca_call_monop_bang(self, ca_monop_#{name}); }
+}
+  DEFINITIONS << io.string
+  if op
+    METHODS     << %{
+  rb_define_method(rb_cCArray, "#{op}", rb_ca_#{name}, 0);
+}
+  end
+  METHODS     << %{
+  rb_define_method(rb_cCArray, "#{name}!", rb_ca_#{name}_bang, 0);
+}
+  DEFINITIONS << %{
+static VALUE rb_cmath_#{name} (VALUE mod, VALUE arg)
+{ return ca_math_call(mod, arg, rb_intern("#{name}")); }
+}
+  METHODS << %{
+  rb_define_module_function(rb_mCAMath, "#{name}", rb_cmath_#{name}, 1);
+}
+end
+
+
+def monop (op, name, hash)
+  io = StringIO.new
+  io.puts
+  io.puts "/*----------------------- #{name} --------------------------*/"
+  hash.each do |types, expr0|
+    if not expr0
+      next
+    end
+    expr0.gsub!(/#/, '*p')
+    types.each do |type|
+      if type
+        expr = expr0.gsub(/<type>/, type)
+        omp_ok = ( type != "VALUE" ) ? 1 : 0
+        io.print %{
+static void
+ca_monop_#{name}_#{type} (int32_t n, boolean8_t *m, char *ptr1, int32_t i1, char *ptr2, int32_t i2)
+{
+  #{type} *q1 = (#{type} *) ptr1, *q2 = (#{type} *) ptr2;
+  #{type} *p1 = q1, *p2 = q2;
+  int32_t k;
+  if ( m ) {
+    boolean8_t *pm;
+    #if defined(_OPENMP) && #{omp_ok}
+    #pragma omp parallel for private(pm,p1,p2)
+    #endif
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        {
+          #{expr} 
+        }
+      }
+    }
+  }
+  else {
+    #if defined(_OPENMP) && #{omp_ok}
+    #pragma omp parallel for private(p1,p2)
+    #endif
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      {
+        #{expr} 
+      }
+    }
+  }
+}
+}
+      end
+    end
+  end
+  io.puts
+  io.puts "ca_monop_func_t"
+  io.puts "ca_monop_#{name}[CA_NTYPE] = {"
+  ALL_TYPES.each_index do |i|
+    type = nil
+    hash.each do |types, expr|
+      if not expr
+        next
+      end
+      type ||= types[i]
+    end
+    if type
+      io.puts("  ca_monop_#{name}_#{type},")
+    else
+      io.puts("  ca_monop_not_implement,")
+    end
+  end
+  io.puts "};"
+  io.puts
+  io.print %{
+static VALUE rb_ca_#{name} (VALUE self)
+{ return rb_ca_call_monop(self, ca_monop_#{name}); }
+static VALUE rb_ca_#{name}_bang (VALUE self)
+{ return rb_ca_call_monop_bang(self, ca_monop_#{name}); }
+  }
+  DEFINITIONS << io.string
+  if op
+    METHODS     << %{
+  rb_define_method(rb_cCArray, "#{op}", rb_ca_#{name}, 0);
+}
+  end
+  METHODS     << %{
+  rb_define_method(rb_cCArray, "#{name}!", rb_ca_#{name}_bang, 0);
+}
+
+end
+
+def binop (op, name, hash)
+  io = StringIO.new
+  io.puts
+  io.puts "/*----------------------- #{name} --------------------------*/"
+  hash.each do |types, expr0|
+    if not expr0
+      next
+    end
+    expr0.gsub!(/#/, '*p')
+    types.each do |type|
+      if type
+        expr = expr0.gsub(/<type>/, type)
+        omp_ok = ( type != "VALUE" ) ? 1 : 0
+        io.print %{
+static void
+ca_binop_#{name}_#{type} (int32_t n, boolean8_t *m, char *ptr1, int32_t i1, char *ptr2, int32_t i2, char *ptr3, int32_t i3)
+{
+  #{type} *q1 = (#{type} *) ptr1, *q2 = (#{type} *) ptr2, *q3 = (#{type} *) ptr3;
+  #{type} *p1 = q1, *p2 = q2, *p3 = q3;
+  int32_t k;
+  if ( m ) {
+    boolean8_t *pm;
+    #if defined(_OPENMP) && #{omp_ok}
+    #pragma omp parallel for private(pm,p1,p2,p3)
+    #endif
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        {
+          #{expr} 
+        }
+      }
+    }
+  }
+  else {
+    #if defined(_OPENMP) && #{omp_ok}
+    #pragma omp parallel for private(p1,p2,p3)
+    #endif
+    for (k=0; k<n; k++) {
+      p1 = q1 + k*i1;
+      p2 = q2 + k*i2;
+      p3 = q3 + k*i3;
+      {
+        #{expr}
+      }
+    }
+  }
+}
+}
+      end
+    end
+  end
+  io.puts
+  io.puts "ca_binop_func_t"
+  io.puts "ca_binop_#{name}[CA_NTYPE] = {"
+  ALL_TYPES.each_index do |i|
+    type = nil
+    hash.each do |types, expr|
+      if not expr
+        next
+      end
+      type ||= types[i]
+    end
+    if type
+      io.puts("  ca_binop_#{name}_#{type},")
+    else
+      io.puts("  ca_binop_not_implement,")
+    end
+  end
+  io.puts "};"
+  io.puts
+  io.print %{
+static VALUE rb_ca_#{name} (VALUE self, VALUE other)
+{ return rb_ca_call_binop(self, other, ca_binop_#{name}); }
+static VALUE rb_ca_#{name}_bang (VALUE self, VALUE other)
+{ return rb_ca_call_binop_bang(self, other, ca_binop_#{name}); }
+  }
+  DEFINITIONS << io.string
+  if op
+    METHODS     << %{
+  rb_define_method(rb_cCArray, "#{op}", rb_ca_#{name}, 1);
+}
+  end
+  METHODS     << %{
+  rb_define_method(rb_cCArray, "#{op}!", rb_ca_#{name}_bang, 1);
+}
+
+end
+
+def moncmp (op, name, hash)
+  io = StringIO.new
+  io.puts
+  io.puts "/*----------------------- #{name} --------------------------*/"
+  hash.each do |types, expr0|
+    if not expr0
+      next
+    end
+    expr0.gsub!(/#/, '*p')
+    types.each do |type|
+      if type
+        expr = expr0.gsub(/<type>/, type)
+        omp_ok = ( type != "VALUE" ) ? 1 : 0
+        io.print %{
+static void
+ca_moncmp_#{name}_#{type} (int32_t n, boolean8_t *m, char *ptr1, int32_t i1, boolean8_t *ptr2, int32_t i2)
+{
+  #{type} *q1 = (#{type} *) ptr1;
+  #{type} *p1 = q1;
+  boolean8_t *q2 = (boolean8_t *) ptr2;
+  boolean8_t *p2 = q2;
+  int32_t k;
+  if ( m ) {
+    boolean8_t *pm = m;
+    #if defined(_OPENMP) && #{omp_ok}
+    #pragma omp parallel for private(pm,p1,p2)
+    #endif
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        {
+          #{expr} 
+        }
+      }
+    }
+  }
+  else {
+    #if defined(_OPENMP) && #{omp_ok}
+    #pragma omp parallel for private(p1,p2)
+    #endif
+    for (k=0; k<n; k++) {
+      p1=q1+k*i1;
+      p2=q2+k*i2;
+      {
+        #{expr}
+      }
+    }
+  }
+}
+}
+      end
+    end
+  end
+  io.puts
+  io.puts "ca_moncmp_func_t"
+  io.puts "ca_moncmp_#{name}[CA_NTYPE] = {"
+  ALL_TYPES.each_index do |i|
+    type = nil
+    hash.each do |types, expr|
+      if not expr
+        next
+      end
+      type ||= types[i]
+    end
+    if type
+      io.puts("  ca_moncmp_#{name}_#{type},")
+    else
+      io.puts("  ca_moncmp_not_implement,")
+    end
+  end
+  io.puts "};"
+  io.puts
+  io.print %{
+static VALUE rb_ca_#{name} (VALUE self, VALUE other)
+{ return rb_ca_call_moncmp(self, ca_moncmp_#{name}); }
+  }
+  DEFINITIONS << io.string
+  if op
+    METHODS     << %{
+  rb_define_method(rb_cCArray, "#{op}", rb_ca_#{name}, 0);
+}
+  end
+end
+
+EPSILON = {
+  "float32_t" => "FLT_EPSILON",
+  "float64_t" => "DBL_EPSILON",
+  "float128_t" => "DBL_EPSILON",
+}
+
+def bincmp (op, name, hash)
+  io = StringIO.new
+  io.puts
+  io.puts "/*----------------------- #{name} --------------------------*/"
+  hash.each do |types, expr0|
+    if not expr0
+      next
+    end
+    expr0.gsub!(/#(\d)/, '*p\1')
+    types.each do |type|
+      if type 
+        expr = expr0.clone
+        expr.gsub!(/<type>/, type)
+        expr.gsub!(/<epsilon>/, EPSILON[type]||"")
+        if type != "fixlen"
+          omp_ok = ( type != "VALUE" ) ? 1 : 0
+          io.print %{
+static void
+ca_bincmp_#{name}_#{type} (int32_t n, boolean8_t *m, 
+                           char *ptr1, int32_t b1, int32_t i1, 
+                           char *ptr2, int32_t b2, int32_t i2, 
+                           char *ptr3, int32_t b3, int32_t i3)
+{
+  #{type} *q1 = (#{type} *) ptr1, *q2 = (#{type} *) ptr2;
+  #{type} *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  int32_t k;
+  if ( m ) {
+    boolean8_t *pm = m;
+    #if defined(_OPENMP) && #{omp_ok}
+    #pragma omp parallel for private(pm,p1,p2,p3)
+    #endif
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*i1;
+        p2 = q2 + k*i2;
+        p3 = q3 + k*i3;
+        {
+          #{expr} 
+        }
+      }
+    }
+  }
+  else {
+    #if defined(_OPENMP) && #{omp_ok}
+    #pragma omp parallel for private(p1,p2,p3)
+    #endif
+    for (k=0; k<n; k++) {
+      p1=q1+k*i1;
+      p2=q2+k*i2;
+      p3=q3+k*i3;
+      {
+        #{expr}
+      }
+    }
+  }
+}
+}
+        else ### fixlen
+          omp_ok = 1
+          io.print %{
+static void
+ca_bincmp_#{name}_#{type} (int32_t n, boolean8_t *m, 
+                           char *ptr1, int32_t b1, int32_t i1, 
+                           char *ptr2, int32_t b2, int32_t i2, 
+                           char *ptr3, int32_t b3, int32_t i3)
+{
+  char *q1 = ptr1, *q2 = ptr2;
+  char *p1 = q1, *p2 = q2;
+  boolean8_t *q3 = (boolean8_t *) ptr3;
+  boolean8_t *p3 = q3;
+  int32_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
+  int32_t k;
+  if ( m ) {
+    boolean8_t *pm = m;
+    #if defined(_OPENMP) && #{omp_ok}
+    #pragma omp parallel for private(pm,p1,p2,p3)
+    #endif
+    for (k=0; k<n; k++) {
+      pm = m + k;
+      if ( ! *pm ) {
+        p1 = q1 + k*s1;
+        p2 = q2 + k*s2;
+        p3 = q3 + k*s3;
+        {
+          #{expr} 
+        }
+      }
+    }
+  }
+  else {
+    #if defined(_OPENMP) && #{omp_ok}
+    #pragma omp parallel for private(p1,p2,p3)
+    #endif
+    for (k=0; k<n; k++) {
+      p1=q1+k*s1;
+      p2=q2+k*s2;
+      p3=q3+k*s3;
+      {
+        #{expr}
+      }
+    }    
+  }
+}
+} 
+        end
+      end
+    end
+  end
+  io.puts
+  io.puts "ca_bincmp_func_t"
+  io.puts "ca_bincmp_#{name}[CA_NTYPE] = {"
+  ALL_TYPES.each_index do |i|
+    type = nil
+    hash.each do |types, expr|
+      if not expr
+        next
+      end
+      type ||= types[i]
+    end
+    if type
+      io.puts("  ca_bincmp_#{name}_#{type},")
+    else
+      io.puts("  ca_bincmp_not_implement,")
+    end
+  end
+  io.puts "};"
+  io.puts
+  io.print %{
+static VALUE rb_ca_#{name} (VALUE self, VALUE other)
+{ return rb_ca_call_bincmp(self, other, ca_bincmp_#{name}); }
+  }
+  DEFINITIONS << io.string
+  if op
+    METHODS     << %{
+  rb_define_method(rb_cCArray, "#{op}", rb_ca_#{name}, 1);
+}
+  end
+end
+
+def alias_op (op, name)
+  METHODS     << %{
+  rb_define_alias(rb_cCArray, "#{op}", "#{name}");
+}
+end
+
+ALL_TYPES = [
+  nil,
+  nil,
+  "int8_t",
+  "uint8_t",
+  "int16_t",
+  "uint16_t",
+  "int32_t",
+  "uint32_t",
+  "int64_t",
+  "uint64_t",
+  "float32_t",
+  "float64_t",
+  "float128_t",
+  nil,
+  nil,
+  nil,
+  nil,
+]
+
+BOOL_TYPES = [
+  nil,
+  "boolean8_t",
+  nil, #"int8_t",
+  nil, #"uint8_t",
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+]
+
+INT_TYPES = [
+  nil,
+  nil,
+  "int8_t",
+  "uint8_t",
+  "int16_t",
+  "uint16_t",
+  "int32_t",
+  "uint32_t",
+  "int64_t",
+  "uint64_t",
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+]
+
+FLOAT_TYPES = [
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  "float32_t",
+  "float64_t",
+  "float128_t",
+  nil,
+  nil,
+  nil,
+  nil,
+]
+
+CMPLX_TYPES = [
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  "cmplx64_t",
+  "cmplx128_t",
+  "cmplx256_t",
+  nil,
+]
+
+OBJ_TYPES = [
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  "VALUE",
+]
+
+FIXLEN_TYPES = [
+  "fixlen",
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+  nil,
+]
+
+begin
+  open("carray_config.h") { |io|
+    have_complex = false
+    while line = io.gets
+      if line =~ /HAVE_COMPLEX_H\s+(\d*)\s*/
+        have_complex = ($1.to_i == 1)
+        break
+      end
+    end
+    HAVE_COMPLEX = have_complex
+  }
+end
+
+HEADERS     = ""
+DEFINITIONS = ""
+METHODS     = ""
+
+CODETEXT    = <<HERE
+<headers>
+
+#include <math.h>
+#include "carray.h"
+
+<definitions>
+
+void
+Init_<name> ()
+{
+  <methods>
+}
+
+HERE
+
+def create_code (name, filename)
+  code = CODETEXT.clone
+  code.sub!("<name>", name)
+  code.sub!("<headers>", HEADERS)
+  code.sub!("<definitions>", DEFINITIONS)
+  code.sub!("<methods>", METHODS)
+  open(filename, "w") { |io|
+    io.write code
+  }
+end
+