numo-gsl-alt 0.1.3

data/ext/numo/gsl/fit/tmpl/fit_mul.c

@@ -0,0 +1,50 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1,*p2;
+    double  *p3,*p4,*p5;
+    ssize_t  s1, s2;
+
+    n = lp->args[0].shape[0];
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    p3 = (double*)GET_PTR(lp,2);
+    p4 = (double*)GET_PTR(lp,3);
+    p5 = (double*)GET_PTR(lp,4);
+
+    <%=func_name%>((double*)p1,s1/sizeof(double),
+                   (double*)p2,s2/sizeof(double),
+                   n,p3,p4,p5);
+}
+
+/*
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[2][1]%>)
+  @param  [DFloat]    <%=args[0][1]%> (input array)
+  @param  [DFloat]    <%=args[2][1]%> (input array)
+  @return [GSL::Fit::<%=result_class%>] result Struct with members: <%=args[5][1]%>, <%=args[6][1]%>, <%=args[7][1]%>.
+
+  <%=desc%>
+
+*/
+static VALUE
+<%=c_func(2)%>(VALUE mod, VALUE v1, VALUE v2)
+{
+    VALUE r, result;
+    ndfunc_arg_in_t ain[2] = {{cDF,1},{cDF,1}};
+    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, STRIDE_LOOP_NIP|NDF_EXTRACT,
+                     2, 3, ain, aout };
+    narray_t *x,*y;
+
+    GetNArray(v1,x);
+    GetNArray(v2,y);
+    CHECK_GE_1D(x);
+    CHECK_GE_1D(y);
+    CHECK_SIZE_EQ(VEC_SIZE(x),VEC_SIZE(y),"x size does not match y size");
+
+    r = na_ndloop(&ndf, 2, v1, v2);
+    result = rb_class_new_instance(3, RARRAY_PTR(r), c<%=result_class%>);
+    RB_GC_GUARD(r);
+    return result;
+}

data/ext/numo/gsl/fit/tmpl/fit_mul_est.c

@@ -0,0 +1,47 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   i;
+    char    *p1,*p2,*p3,*p4,*p5;
+    ssize_t  s1, s2, s3, s4, s5;
+    double   x,c1,cov11,y,ye;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+    INIT_PTR(lp, 3, p4, s4);
+    INIT_PTR(lp, 4, p5, s5);
+
+    for (; i--; ) {
+        GET_DATA_STRIDE(p1,s1,double,x);
+        GET_DATA_STRIDE(p2,s2,double,c1);
+        GET_DATA_STRIDE(p3,s3,double,cov11);
+        <%=func_name%>(x, c1, cov11, &y, &ye);
+        SET_DATA_STRIDE(p4,s4,double,y);
+        SET_DATA_STRIDE(p5,s5,double,ye);
+    }
+}
+
+/*
+  @overload <%=name%>(<%=args[0][1]%>, mul_result)
+  @param  [DFloat]    <%=args[0][1]%>
+  @param  [(M|Wm)ulResult]  mul_result  Result of GSL::Fit.mul|wmul
+  @return [[DFloat,DFloat]] array of [<%=args[3][1]%>,<%=args[4][1]%>]
+
+  <%=desc%>
+
+*/
+static VALUE
+<%=c_func(2)%>(VALUE mod, VALUE v1, VALUE v2)
+{
+    ndfunc_arg_in_t ain[3] = {{cDF,0},{cDF,0},{cDF,0}};
+    ndfunc_arg_out_t aout[2] = {{cDF,0},{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, STRIDE_LOOP_NIP|NDF_EXTRACT,
+                     3, 2, ain, aout };
+    VALUE c1, cov11;
+
+    c1 = RSTRUCT_GET(v2,0);
+    cov11 = RSTRUCT_GET(v2,1);
+    return na_ndloop(&ndf, 3, v1, c1, cov11);
+}

data/ext/numo/gsl/fit/tmpl/fit_wlinear.c

@@ -0,0 +1,59 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1,*p2,*p3;
+    double  *p4,*p5,*p6,*p7,*p8,*p9;
+    ssize_t  s1, s2, s3;
+
+    n = lp->args[0].shape[0];
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+    p4 = (double*)GET_PTR(lp,3);
+    p5 = (double*)GET_PTR(lp,4);
+    p6 = (double*)GET_PTR(lp,5);
+    p7 = (double*)GET_PTR(lp,6);
+    p8 = (double*)GET_PTR(lp,7);
+    p9 = (double*)GET_PTR(lp,8);
+
+    <%=func_name%>((double*)p1,s1/sizeof(double),
+                   (double*)p2,s2/sizeof(double),
+                   (double*)p3,s3/sizeof(double),
+                   n,p4,p5,p6,p7,p8,p9);
+}
+
+/*
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[2][1]%>,<%=args[4][1]%>)
+  @param  [DFloat]    <%=args[0][1]%> (input array)
+  @param  [DFloat]    <%=args[2][1]%> (input array)
+  @param  [DFloat]    <%=args[4][1]%> (input array)
+  @return [GSL::Fit::<%=result_class%>] result Struct with members: <%=args[7][1]%>, <%=args[8][1]%>, <%=args[9][1]%>, <%=args[10][1]%>, <%=args[11][1]%>, <%=args[12][1]%>.
+
+  <%=desc%>
+
+*/
+static VALUE
+<%=c_func(3)%>(VALUE mod, VALUE v1, VALUE v2, VALUE v3)
+{
+    ndfunc_arg_in_t ain[3] = {{cDF,1},{cDF,1},{cDF,1}};
+    ndfunc_arg_out_t aout[6] = {{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cDF,0},{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, STRIDE_LOOP_NIP|NDF_EXTRACT,
+                     3, 6, ain, aout };
+    narray_t *x, *y, *w;
+    VALUE r, result;
+
+    GetNArray(v1,x);
+    GetNArray(v2,y);
+    GetNArray(v3,w);
+    CHECK_GE_1D(x);
+    CHECK_GE_1D(y);
+    CHECK_GE_1D(w);
+    CHECK_SIZE_EQ(VEC_SIZE(x),VEC_SIZE(y),"y size does not match x size");
+    CHECK_SIZE_EQ(VEC_SIZE(x),VEC_SIZE(w),"w size does not match x size");
+
+    r = na_ndloop(&ndf, 3, v1, v2, v3);
+    result = rb_class_new_instance(6, RARRAY_PTR(r), c<%=result_class%>);
+    RB_GC_GUARD(r);
+    return result;
+}

data/ext/numo/gsl/fit/tmpl/fit_wmul.c

@@ -0,0 +1,56 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1,*p2,*p3;
+    double  *p4,*p5,*p6;
+    ssize_t  s1, s2, s3;
+
+    n = lp->args[0].shape[0];
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+    p4 = (double*)GET_PTR(lp,3);
+    p5 = (double*)GET_PTR(lp,4);
+    p6 = (double*)GET_PTR(lp,5);
+
+    <%=func_name%>((double*)p1,s1/sizeof(double),
+                   (double*)p2,s2/sizeof(double),
+                   (double*)p3,s3/sizeof(double),
+                   n,p4,p5,p6);
+}
+
+/*
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[2][1]%>,<%=args[4][1]%>)
+  @param  [DFloat]    <%=args[0][1]%> (input array)
+  @param  [DFloat]    <%=args[2][1]%> (input array)
+  @param  [DFloat]    <%=args[4][1]%> (input array)
+  @return [GSL::Fit::<%=result_class%>] result Struct with members: <%=args[7][1]%>, <%=args[8][1]%>, <%=args[9][1]%>.
+
+  <%=desc%>
+
+*/
+static VALUE
+<%=c_func(3)%>(VALUE mod, VALUE v1, VALUE v2, VALUE v3)
+{
+    VALUE r, result;
+    ndfunc_arg_in_t ain[3] = {{cDF,1},{cDF,1},{cDF,1}};
+    ndfunc_arg_out_t aout[3] = {{cDF,0},{cDF,0},{cDF,0}};
+    ndfunc_t ndf = { iter_<%=c_func%>, STRIDE_LOOP_NIP|NDF_EXTRACT,
+                     3, 3, ain, aout };
+    narray_t *x,*y,*w;
+
+    GetNArray(v1,x);
+    GetNArray(v2,y);
+    GetNArray(v3,w);
+    CHECK_GE_1D(x);
+    CHECK_GE_1D(y);
+    CHECK_GE_1D(w);
+    CHECK_SIZE_EQ(VEC_SIZE(x),VEC_SIZE(y),"y size does not match x size");
+    CHECK_SIZE_EQ(VEC_SIZE(x),VEC_SIZE(w),"w size does not match x size");
+
+    r = na_ndloop(&ndf, 3, v1, v2, v3);
+    result = rb_class_new_instance(3, RARRAY_PTR(r), c<%=result_class%>);
+    RB_GC_GUARD(r);
+    return result;
+}

data/ext/numo/gsl/gen/erbln.rb

@@ -0,0 +1,132 @@
+require 'erb'
+
+class ErbPP
+
+  class CountLnString < String
+
+    def initialize(filename)
+      @filename = filename
+      @lnchar = "\n"
+      @buf = ""
+      @str = ""
+      @countln = 1
+      @current = 1
+      super("\n"+report_line)
+    end
+
+    def report_line
+      "#line #{@current} \"#{@filename}\"\n"
+    end
+
+    def concat0(s)
+      ln(caller[0])
+      @buf.concat(s)
+      @str.concat(s)
+    end
+
+    def concat1(s)
+      ln(caller[0])
+      @buf.concat(s)
+    end
+
+    def ln(status=nil)
+      case status
+      when /:(\d+):/
+        n = $1.to_i
+      else
+        n = status.to_i
+      end
+      return if n == @current
+      if @current != @countln || @postpone
+        if /\A\s*\z/ =~ @str || /\A#line / =~ @buf
+          @postpone = true
+        elsif @in_comment
+          @postpone = false
+        else
+          if self[-1] != "\n"
+            concat("\n")
+          end
+          concat(report_line)
+          @postpone = false
+        end
+      end
+      concat(@buf)
+
+      b = @buf.gsub(/".*?(?<!\\)"/,'""')
+      /^.*(\/\*)(.*?)$/ =~ b
+      x = $2
+      /^.*(\*\/)(.*?)$/ =~ b
+      y = $2
+      if x
+        if y
+          if x.size < y.size
+            #:in_comment
+            @in_comment = true
+          else
+            #:out_comment
+            @in_comment = false
+          end
+        else
+          #:in_comment
+          @in_comment = true
+        end
+      else
+        if y
+          #:out_comment
+          @in_comment = false
+        else
+          #:keep
+        end
+      end
+
+      @countln = @current + @buf.count(@lnchar)
+      @current = n
+      @buf = ""
+      @str = ""
+    end
+
+    def d(s)
+      p [s, [x,y], r]
+      r
+    end
+
+    def final
+      ln(caller[0])
+      concat(@buf)
+    end
+
+  end
+
+  class ERBLN
+
+    def initialize(str, filename, trim_mode=nil, eoutvar='_erbout')
+      @filename = filename
+      compiler = ERB::Compiler.new(trim_mode)
+      set_eoutvar(compiler, eoutvar)
+      @src, @enc = *compiler.compile(str)
+    end
+
+    def set_eoutvar(compiler, eoutvar = '_erbout')
+      compiler.put_cmd = "#{eoutvar}.concat0"
+      compiler.insert_cmd = "#{eoutvar}.concat1"
+      compiler.pre_cmd = ["#{eoutvar} = CountLnString.new(#{@filename.inspect})"]
+      compiler.post_cmd = ["#{eoutvar}.final"]
+    end
+
+    def run(b)
+      print self.result(b)
+    end
+
+    def result(b)
+      #open("tmpout","a") do |f|
+      #  f.puts "\n#file:#{@filename}"
+      #  f.puts @src
+      #end
+      eval(@src, b, (@filename || '(erb)'), 0)
+    end
+
+    #require "fileutils"
+    #FileUtils.rm_f("tmpout")
+  end
+
+end

data/ext/numo/gsl/gen/erbpp2.rb

@@ -0,0 +1,344 @@
+require "erb"
+require_relative "erbln"
+
+class ErbPP
+
+  def initialize(parent=nil, erb_base=nil, **opts, &block)
+    @parent = parent
+    @children = []
+    @opts = opts
+    set erb_base: erb_base if erb_base
+    @parent.add_child(self) if @parent
+    instance_eval(&block) if block
+  end
+
+  attr_reader :children
+  attr_accessor :parent
+
+  def add_child(child)
+    @children.push(child)
+  end
+
+  def set(**opts)
+    @opts.merge!(opts)
+  end
+
+  def get(key, *args, &block)
+    if respond_to?(key)
+      return send(key, *args, &block)
+    end
+    if args.empty? && block.nil? && @opts.has_key?(key)
+      return @opts[key]
+    end
+    if @parent
+      return @parent.get(key, *args, &block)
+    end
+    nil
+  end
+
+  def description
+    if s = @opts[:description] || @opts[:desc]
+      s.gsub(/\@\{/,"[").gsub(/\@\}/,"]")
+    end
+  end
+
+  alias desc description
+
+  alias method_missing_alias method_missing
+
+  def method_missing(_meth_id, *args, &block)
+    if args.empty?
+      #$stderr.puts _meth_id.inspect
+      v = get(_meth_id, *args, &block)
+      return v if !v.nil?
+    end
+    method_missing_alias(_meth_id, *args, &block)
+  end
+
+  # ERB Loader
+
+  def load_erb(base_name)
+    safe_level = nil
+    trim_mode = '%<>'
+    file = base_name + get(:erb_suffix)
+    dirs = get(:erb_dir)
+    dirs = [dirs] if !dirs.kind_of?(Array)
+    dirs.each do |x|
+      Dir.glob(x).each do |dir|
+        path = File.join(dir,file)
+        if File.exist?(path)
+          if get(:line_number)
+            erb = ERBLN.new(File.read(path), path, trim_mode)
+          else
+            erb = ERB.new(File.read(path), safe_level, trim_mode)
+            erb.filename = path
+          end
+          return erb
+        end
+      end
+    end
+    raise "file not found: #{file.inspect} in #{dirs.inspect}"
+  end
+
+  def run
+    if base = @opts[:erb_base]
+      load_erb(base).run(binding)
+    end
+  end
+
+  def result
+    if base = @opts[:erb_base]
+      load_erb(base).result(binding)
+    end
+  end
+
+  def write(output)
+    File.open(output,"wt") do |f|
+      f.print(result)
+    end
+  end
+
+  def init_def
+  end
+
+  def find_tmpl(name)
+    @parent.children.find{|x| x.name == name }
+  end
+
+  def find(name)
+    children.find{|x| x.name == name }
+  end
+end
+
+
+class DefLib < ErbPP
+  def initialize(parent=nil, **opts, &block)
+    opts[:erb_base] ||= 'lib'
+    opts[:include_files] ||= []
+    super(parent, **opts, &block)
+  end
+  def id_assign
+    ids = []
+    @children.each{|c| a=c.get(:id_list); ids.concat(a) if a}
+    ids.sort.uniq.map{|x| "id_#{x[1]} = rb_intern(\"#{x[0]}\");"}
+  end
+  def id_decl
+    ids = []
+    @children.each{|c| a=c.get(:id_list); ids.concat(a) if a}
+    ids.sort.uniq.map{|x| "static ID id_#{x[1]};\n"}
+  end
+  def def_class(**opts, &block)
+    DefClass.new(self, **opts, &block)
+  end
+  def def_module(**opts, &block)
+    DefModule.new(self, **opts, &block)
+  end
+end
+
+module DeclMethod
+  def def_alloc_func(m, erb_path=nil, **opts, &block)
+    DefAllocFunc.new(self, erb_path||m, name:m, singleton:true, **opts, &block)
+  end
+  def undef_alloc_func
+    UndefAllocFunc.new(self)
+  end
+  def def_method(m, erb_path=nil, **opts, &block)
+    DefMethod.new(self, erb_path||m, name:m, **opts, &block)
+  end
+  def undef_method(m)
+    UndefMethod.new(self,name:m)
+  end
+  def def_singleton_method(m, erb_path=nil, **opts, &block)
+    DefMethod.new(self, erb_path||m, name:m, singleton:true, **opts, &block)
+  end
+  def undef_singleton_method(m)
+    UndefSingletonMethod.new(self,name:m)
+  end
+  def def_module_function(m, erb_path=nil, **opts, &block)
+    DefModuleFunction.new(self, erb_path||m, name:m, **opts, &block)
+  end
+  def def_alias(from, to)
+    DefAlias.new(self, from:from, to:to)
+  end
+  def def_const(m, v, **opts, &block)
+    DefConst.new(self, name:m, value:v, **opts, &block)
+  end
+end
+
+class DefModule < ErbPP
+  include DeclMethod
+  def initialize(parent, **opts, &block)
+    eb = opts[:erb_base] || 'module'
+    super(parent, erb_base:eb, **opts, &block)
+  end
+  def id_list
+    @id_list ||= []
+  end
+  def def_id(name,var=nil)
+    var = name.gsub(/\?/,"_p").gsub(/\!/,"_bang") if var.nil?
+    id_list << [name,var]
+  end
+  def init_def
+    load_erb(init_erb).result(binding)
+  end
+  def init_erb
+    @opts[:init_erb] || "init_module"
+  end
+  def method_code
+    @children.map{|c| c.result}.join("\n")
+  end
+  def _mod_var
+    @opts[:module_var]
+  end
+end
+
+class DefClass < DefModule
+  def initialize(parent, **opts, &block)
+    eb = opts[:erb_base] || 'class'
+    super(parent, erb_base:eb, **opts, &block)
+  end
+  def _mod_var
+    @opts[:class_var]
+  end
+  def init_erb
+    @opts[:init_erb] || "init_class"
+  end
+  def super_class
+    @opts[:super_class] || "rb_cObject"
+  end
+  def free_func
+    @opts[:free_func] || "gsl_"+get(:name)+"_free"
+  end
+end
+
+class DefMethod < ErbPP
+  include DeclMethod
+
+  def initialize(parent, erb_base, **opts, &block)
+    super(parent, **opts, &block)
+    set erb_base: erb_base
+  end
+
+  def id_op
+    if op.size == 1
+      "'#{op}'"
+    else
+      "id_#{c_name}"
+    end
+  end
+
+  def c_name
+    @opts[:name].gsub(/\?/,"_p").gsub(/\!/,"_bang").gsub(/=/,"_set")
+  end
+
+  def op_map
+    @opts[:op] || @opts[:name]
+  end
+
+  def c_func(n_arg=nil)
+    set n_arg: n_arg if n_arg
+    s = (singleton) ? "_s" : ""
+    "#{@parent.name}#{s}_#{c_name}"
+  end
+
+  def c_iter
+    "iter_#{c_func}"
+  end
+
+  def define_method_args
+    "#{_mod_var}, \"#{op_map}\", #{c_func}, #{n_arg}"
+  end
+
+  def init_def
+    return if n_arg == :nodef
+    s = (singleton) ? "_singleton" : ""
+    "rb_define#{s}_method(#{define_method_args});"
+  end
+
+  def singleton
+    @opts[:singleton]
+  end
+end
+
+class DefModuleFunction < DefMethod
+  def initialize(parent, erb_base, **opts, &block)
+    super(parent, erb_base, **opts, &block)
+    set singleton: true
+  end
+
+  def init_def
+    return if n_arg == :nodef
+    "rb_define_module_function(#{define_method_args});"
+  end
+end
+
+class DefAlias < ErbPP
+  def init_def
+    "rb_define_alias(#{_mod_var}, \"#{from}\", \"#{to}\");"
+  end
+end
+
+class DefAllocFunc < DefMethod
+  def init_def
+    "rb_define_alloc_func(#{_mod_var}, #{c_func});"
+  end
+end
+
+class UndefAllocFunc < ErbPP
+  def init_def
+    "rb_undef_alloc_func(#{_mod_var});"
+  end
+end
+
+class UndefMethod < ErbPP
+  def init_def
+    "rb_undef_method(#{_mod_var},\"#{name}\");"
+  end
+end
+
+class UndefSingletonMethod < ErbPP
+  def init_def
+    "rb_undef_method(rb_singleton_class(#{_mod_var}),\"#{name}\");"
+  end
+end
+
+class DefConst < ErbPP
+  def init_def
+    "/*#{desc}*/
+    rb_define_const(#{_mod_var},\"#{name}\",#{value});"
+  end
+end
+
+class DefError < ErbPP
+  def initialize(parent, name, sup_var, **opts, &block)
+    super(parent, error_name:name, error_var:"e"+name, super_var:sup_var,
+          **opts, &block)
+  end
+  def result
+    "static VALUE #{error_var};"
+  end
+  def init_def
+    "/*#{description}*/
+    #{error_var} = rb_define_class_under(#{ns_var},\"#{error_name}\",#{super_var});"
+  end
+end
+
+class DefStruct < ErbPP
+  def method_code
+    "static VALUE #{class_var};"
+  end
+  def init_def
+    items = members.map{|s| "\"#{s}\""}.join(",")
+    "/*#{description}*/
+    #{class_var} = rb_struct_define(\"#{class_name}\",#{items},NULL);"
+  end
+end
+
+class DefInclueModule < ErbPP
+  def initialize(parent=nil, incl_class, incl_module, **opts, &block)
+    super(parent,incl_class:incl_class,incl_module:incl_module,**opts,&block)
+  end
+  def init_def
+    "rb_include_module(#{get(:incl_class)}, #{get(:incl_module)});"
+  end
+end