numo-gsl 0.1.0

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/erbpp2.rb

@@ -0,0 +1,306 @@
+require "erb"
+
+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)
+          erb = ERB.new(File.read(path), safe_level, trim_mode)
+          erb.filename = path
+          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'
+    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 def_singleton_method(m, erb_path=nil, **opts, &block)
+    DefMethod.new(self, erb_path||m, name:m, singleton:true, **opts, &block)
+  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")
+  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 DefConst < ErbPP
+  def init_def
+    "/*#{desc}*/
+    rb_define_const(#{_mod_var},\"#{name}\",#{value});"
+  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