numo-gsl 0.1.0

data/ext/numo/gsl/sf/parse_sf.rb

@@ -0,0 +1,277 @@
+require_relative "../gen/erbpp_gsl"
+
+class DefSf < DefModule
+
+  def check_func(h)
+    if /These functions are now deprecated/m =~ h[:desc]
+      $stderr.puts "depricated: #{h[:func_name]}"
+      return false
+    end
+    if /This function is now deprecated/m =~ h[:desc]
+      $stderr.puts "depricated: #{h[:func_name]}"
+      return false
+    end
+    [
+     LegendreArray,
+     MathieuArray,
+     BesselArray,
+     CoulombArray,
+     GegenpolyArray,
+     SfTemplate,
+     SfBasic
+    ].each do |c|
+      if tmpl = c.lookup(h)
+        c.new(self, tmpl, **h)
+        return true
+      end
+    end
+    $stderr.puts "skip #{h[:func_type]} #{h[:func_name]} #{h[:args].inspect}"
+    false
+  end
+
+end
+
+
+class SfTemplate < DefGslModuleFunction
+  include FuncParser
+
+  def self.lookup(h)
+    arg_types = h[:args].map{|a| a[0].sub(/^const /,"")}
+    case h[:func_type]
+    when "int"
+      case arg_types
+      when ["double"];                 "m_Int_f_DFloat"
+      when ["double"]*3;               "m_Int_f_DFloat_x3" # gsl_fcmp
+      when ["int","double"];           "m_Int_f_int_DFloat"
+      when ["int"]+["double"]*2;       "m_Int_f_int_DFloat_x2"
+      end
+    when "double"
+      case arg_types
+      when ["int","double"];           "m_DFloat_f_int_DFloat"
+      when ["int"]*2+["double"]*2;     "m_DFloat_f_int_x2_DFloat_x2"
+      when ["double","gsl_mode_t"];    "m_DFloat_f_DFloat_mode"
+      when ["double"];                 "m_DFloat_f_DFloat"
+      when ["double"]*2;               "m_DFloat_f_DFloat_x2"
+      when ["double"]*3;               "m_DFloat_f_DFloat_x3"
+      when ["int"];                    "m_DFloat_f_Int"
+      when ["double","int"];           "m_DFloat_f_DFloat_Int"
+      when ["double","int *"];         "m_DFloat_Int_f_DFloat"  # gsl_frexp
+      when ["double","unsigned int"];  "m_DFloat_f_DFloat_UInt"
+      when ["unsigned int"];           "m_DFloat_f_UInt"
+      end
+    end
+  end
+
+  def initialize(parent,tmpl,**h)
+    m = h[:name] || h[:func_name].sub(/^gsl_sf_/,"")
+    super(parent, tmpl, name:m, **h)
+    parse_args(h)
+    if @args_param.any?{|a| a.type=="gsl_mode_t"}
+      set n_arg: -1
+    else
+      set n_arg: @args_param.size+@args_in.size
+    end
+    @preproc_code = ""
+  end
+
+end
+
+#----------------------------------------------------------
+
+class SfBasic < SfTemplate
+  RE = /^gsl_sf_/
+
+  PARAM_DESC =
+    {
+     "norm"=>"@param [Integer] norm Type of normalization to use. "+
+       "The possible values are: Numo::GSL::Sf::Legendre::NONE, "+
+       "Numo::GSL::Sf::Legendre::SCHMIDT, "+
+       "Numo::GSL::Sf::Legendre::SPHARM, Numo::GSL::Sf::Legendre::FULL",
+     "mode"=>"@param [Integer] mode  The following precision levels are available: "+
+       "Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.",
+     "lmax"=>"@param [Integer] lmax",
+     "csphase"=>"@param [Float] csphase  To include or exclude "+
+       "the Condon-Shortley phase factor of (-1)^m, "+
+       "set the parameter csphase to either -1 or 1 respectively.",
+     "work"=>"@param [Numo::GSL::Sf::MathieuWorkspace] work",
+    }
+  PARAM_NAMES =
+   {
+   "double" => %w[csphase],
+   "int" => true, #%w[n m i j l kmax lmax nmin nmax size order_min order_max],
+   "size_t" => true, #%w[lmax],
+   "gsl_sf_legendre_t" => true,
+   "gsl_mode_t" => true,
+   "gsl_sf_mathieu_workspace *"=>true,
+  }
+
+  def self.lookup(h)
+    if RE =~ h[:func_name]
+      case h[:func_name]
+      when /_(alloc)|(free)$/
+        false
+      when /angle_restrict_\w+_e/ # overwrite on *theta
+        false
+      when /bessel_sequence_Jnu_e/ # overwrite on v[]
+        false
+      else
+        meth = h[:func_name].sub(/^gsl_sf_/,"")
+        if [/^coupling_/,
+            /^legendre_array_(n|index)/,
+            /^psi(_1)?_int/,
+            /^z?eta(m1)?_int/].any?{|re| re =~ meth}
+          "mod_func_scalar"
+        else
+          "mod_func_noloop"
+        end
+      end
+    else
+      false
+    end
+  end
+
+end
+
+
+class MathieuArray < DefMethod
+  RE = /^gsl_sf_mathieu_\w+_array$/
+
+  def self.lookup(h)
+    case h[:func_name]
+    when "gsl_sf_mathieu_alloc"
+      "c_new_sizet_double"
+    when RE
+      arg_types = h[:args].map{|a| a[0].sub(/^const /,"")}
+      tp = "gsl_sf_mathieu_workspace *"
+      case arg_types
+      when ["int"]*2+["double",tp,"double"];     "c_DFloat_f_int_x2_DFloat"
+      when ["int"]*2+["double"]*2+[tp,"double"]; "c_DFloat_f_int_x2_DFloat_x2"
+      when ["int"]*3+["double"]*2+[tp,"double"]; "c_DFloat_f_int_x3_DFloat_x2"
+      end
+    end
+  end
+
+  def initialize(parent,tmpl,**h)
+    super(parent,tmpl,**h)
+
+    case h[:func_name]
+    when "gsl_sf_mathieu_alloc"
+      set name: "new"
+      set singleton: true
+    when /_array$/
+      set name: h[:func_name].sub(/^gsl_sf_mathieu_/,"")
+      set singleton: false
+    end
+
+    case func_name
+    when /_(a|b)_array$/
+      @mathieu_type = :characteristic
+    when /_(c|s)e_array$/
+      @mathieu_type = :angular
+    when /_M(c|s)_array$/
+      @mathieu_type = :radial
+    end
+
+    if @mathieu_type == :radial
+      @preproc_code = <<EOL
+    if (c0!=1 || c0!=2) {
+        rb_raise(rb_eArgError,"j should be 1 or 2");
+    }
+    if (c1<0 || c2<0 || c1>c2) {
+        rb_raise(rb_eArgError,"should be nmin>=0 && nmax>=0 && nmin<=nmax");
+    }
+    shape[0] = c2-c1+1;
+EOL
+      else
+        @preproc_code = <<EOL
+    if (c0<0 || c1<0 || c0>c1) {
+        rb_raise(rb_eArgError,"should be nmin>=0 && nmax>=0 && nmin<=nmax");
+    }
+    shape[0] = c1-c0+1;
+EOL
+    end
+  end
+end
+
+
+class BesselArray < SfBasic
+  RE = /^gsl_sf_bessel_\w+_array$/
+
+  def self.lookup(h)
+    "mod_func_noloop" if RE =~ h[:func_name]
+  end
+
+  def initialize(parent,tmpl,**h)
+    super(parent,tmpl,**h)
+    if n_arg == 3
+      @preproc_code = <<EOL
+    if (c0<0 || c1<0 || c0>c1) {
+        rb_raise(rb_eArgError,"should be nmin>=0 && nmax>=0 && nmin<=nmax");
+    }
+    shape[0] = c1-c0+1;
+EOL
+    else
+      @preproc_code = <<EOL
+    if (c0<0) {
+        rb_raise(rb_eArgError,"should be lmax>=0");
+    }
+    shape[0] = c0+1;
+EOL
+    end
+  end
+end
+
+
+class CoulombArray < SfBasic
+  RE = /^gsl_sf_coulomb_\w+_array$/
+
+  def self.lookup(h)
+    "mod_func_noloop" if RE =~ h[:func_name]
+  end
+
+  def initialize(parent,tmpl,**h)
+    super(parent,tmpl,**h)
+    c = find_name("kmax").c_var
+    @preproc_code = <<EOL
+    if (#{c}<0) {
+        rb_raise(rb_eArgError,"should be kmax>=0");
+    }
+    shape[0] = #{c}+1;
+EOL
+  end
+end
+
+
+class GegenpolyArray < SfBasic
+  RE = /^gsl_sf_gegenpoly_array$/
+
+  def self.lookup(h)
+    "mod_func_noloop" if RE =~ h[:func_name]
+  end
+
+  def initialize(parent,tmpl,**h)
+    super(parent,tmpl,**h)
+    c = find_name("nmax").c_var
+    @preproc_code = <<EOL
+    if (#{c}<0) {
+        rb_raise(rb_eArgError,"should be kmax>=0");
+    }
+    shape[0] = #{c}+1;
+EOL
+  end
+end
+
+
+class LegendreArray < SfBasic
+  RE = /^gsl_sf_legendre\w*_array(_e)?$/
+
+  def self.lookup(h)
+    "mod_func_noloop" if RE =~ h[:func_name]
+  end
+
+  def initialize(parent,tmpl,**h)
+    super(parent,tmpl,**h)
+    c = find_name("lmax").c_var
+    @preproc_code = "    shape[0] = gsl_sf_legendre_array_n(#{c});"
+  end
+end

data/ext/numo/gsl/sf/tmpl/c_DFloat_f_int_x2_DFloat.c

@@ -0,0 +1,50 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    int    c0, c1;
+    double c2, *c4;
+    <%=struct%> *w;
+    void **opt = (void**)(lp->opt_ptr);
+
+    w  = (<%=struct%>*)(opt[0]);
+    c0 = *(int*)(opt[1]); //<%=args[0][1]%>
+    c1 = *(int*)(opt[2]); //<%=args[1][1]%>
+    c2 = *(double*)GET_PTR(lp,0); //<%=args[2][1]%>
+    c4 =  (double*)GET_PTR(lp,1); //<%=args[4][1]%>
+    <%=func_name%>(c0,c1,c2,w,c4);
+}
+
+/*
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[1][1]%>,<%=args[2][1]%>)
+
+  @param [Integer]  <%=args[0][1]%>
+  @param [Integer]  <%=args[1][1]%>
+  @param [Numo::DFloat]  <%=args[2][1]%>
+  @return [Numo::DFloat]  returns <%=args[4][1]%>
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(3)%>(VALUE self, VALUE v0, VALUE v1, VALUE v2)
+{
+    <%=struct%> *w;
+    int nmin, nmax;
+    size_t shape[1];
+    ndfunc_arg_in_t ain[1] = {{cDF,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,1,shape}};
+    ndfunc_t ndf = {iter_<%=c_func%>,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,1,1,ain,aout};
+    void *opt[3];
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+
+    nmin = NUM2INT(v0);
+    nmax = NUM2INT(v1);
+    opt[0] = w;
+    opt[1] = &nmin;
+    opt[2] = &nmax;
+    if (nmin<0 || nmax<0 || nmin>nmax) {
+        rb_raise(rb_eArgError,"should be nmin>=0 && nmax>=0 && nmin<=nmax");
+    }
+    shape[0] = nmax-nmin+1;
+    return na_ndloop3(&ndf,opt,1,v2);
+}

data/ext/numo/gsl/sf/tmpl/c_DFloat_f_int_x2_DFloat_x2.c

@@ -0,0 +1,52 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    int    c0, c1;
+    double c2, c3, *c5;
+    <%=struct%> *w;
+    void **opt = (void**)(lp->opt_ptr);
+
+    w  = (<%=struct%>*)(opt[0]);
+    c0 = *(int*)(opt[1]); //<%=args[0][1]%>
+    c1 = *(int*)(opt[2]); //<%=args[1][1]%>
+    c2 = *(double*)GET_PTR(lp,0); //<%=args[2][1]%>
+    c3 = *(double*)GET_PTR(lp,1); //<%=args[3][1]%>
+    c5 =  (double*)GET_PTR(lp,2); //<%=args[5][1]%>
+    <%=func_name%>(c0,c1,c2,c3,w,c5);
+}
+
+/*
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[1][1]%>,<%=args[2][1]%>,<%=args[3][1]%>)
+
+  @param [Integer]  <%=args[0][1]%>
+  @param [Integer]  <%=args[1][1]%>
+  @param [Numo::DFloat]  <%=args[2][1]%>
+  @param [Numo::DFloat]  <%=args[3][1]%>
+  @return [Numo::DFloat]  returns <%=args[5][1]%>
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(4)%>(VALUE self, VALUE v0, VALUE v1, VALUE v2, VALUE v3)
+{
+    <%=struct%> *w;
+    int nmin, nmax;
+    size_t shape[1];
+    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,1,shape}};
+    ndfunc_t ndf = {iter_<%=c_func%>,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,2,1,ain,aout};
+    void *opt[3];
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+
+    nmin = NUM2INT(v0);
+    nmax = NUM2INT(v1);
+    opt[0] = w;
+    opt[1] = &nmin;
+    opt[2] = &nmax;
+    if (nmin<0 || nmax<0 || nmin>nmax) {
+        rb_raise(rb_eArgError,"should be nmin>=0 && nmax>=0 && nmin<=nmax");
+    }
+    shape[0] = nmax-nmin+1;
+    return na_ndloop3(&ndf,opt,2,v2,v3);
+}

data/ext/numo/gsl/sf/tmpl/c_DFloat_f_int_x3_DFloat_x2.c

@@ -0,0 +1,55 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    int    c0, c1, c2;
+    double c3, c4, *c6;
+    <%=struct%> *w;
+    void **opt = (void**)(lp->opt_ptr);
+
+    w  = (<%=struct%>*)(opt[0]);
+    c0 = *(int*)(opt[1]); //<%=args[0][1]%>
+    c1 = *(int*)(opt[2]); //<%=args[1][1]%>
+    c2 = *(int*)(opt[3]); //<%=args[2][1]%>
+    c3 = *(double*)GET_PTR(lp,0); //<%=args[3][1]%>
+    c4 = *(double*)GET_PTR(lp,1); //<%=args[4][1]%>
+    c6 =  (double*)GET_PTR(lp,2); //<%=args[6][1]%>
+    <%=func_name%>(c0,c1,c2,c3,c4,w,c6);
+}
+
+/*
+  @overload <%=name%>(<%=args[0][1]%>,<%=args[1][1]%>,<%=args[2][1]%>,<%=args[3][1]%>)
+
+  @param [Integer]  <%=args[0][1]%>
+  @param [Integer]  <%=args[1][1]%>
+  @param [Numo::DFloat]  <%=args[2][1]%>
+  @param [Numo::DFloat]  <%=args[3][1]%>
+  @return [Numo::DFloat]  returns <%=args[5][1]%>
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(5)%>(VALUE self, VALUE v0, VALUE v1, VALUE v2, VALUE v3, VALUE v4)
+{
+    <%=struct%> *w;
+    int j, nmin, nmax;
+    size_t shape[1];
+    ndfunc_arg_in_t ain[2] = {{cDF,0},{cDF,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,1,shape}};
+    ndfunc_t ndf = {iter_<%=c_func%>,NO_LOOP|NDF_INPLACE|NDF_EXTRACT,2,1,ain,aout};
+    void *opt[4];
+
+    TypedData_Get_Struct(self, <%=struct%>, &<%=data_type_var%>, w);
+
+    j    = NUM2INT(v0);
+    nmin = NUM2INT(v1);
+    nmax = NUM2INT(v2);
+    opt[0] = w;
+    opt[1] = &j; //j
+    opt[2] = &nmin;
+    opt[3] = &nmax;
+    if (nmin<0 || nmax<0 || nmin>nmax) {
+        rb_raise(rb_eArgError,"should be nmin>=0 && nmax>=0 && nmin<=nmax");
+    }
+    shape[0] = nmax-nmin+1;
+    return na_ndloop3(&ndf,opt,2,v3,v4);
+}

data/ext/numo/gsl/sf/tmpl/m_DFloat_f_DFloat_mode.c

@@ -0,0 +1,47 @@
+static void
+iter_<%=c_func%>(na_loop_t *const lp)
+{
+    size_t   i;
+    char    *p1, *p2;
+    ssize_t  s1, s2;
+    double   x, y;
+    gsl_mode_t c1;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+
+    c1 = *(gsl_mode_t*)(lp->opt_ptr);
+
+    for (; i--;) {
+        GET_DATA_STRIDE(p1,s1,double,x);
+        y = <%=func_name%>(x, c1);
+        SET_DATA_STRIDE(p2,s2,double,y);
+    }
+}
+
+/*
+  @overload <%=name%>(<%=args[0][1]%>[,<%=args[1][1]%>])
+  @param  [DFloat]   <%=args[0][1]%>
+  @param  [Integer]  <%=args[1][1]%> The following precision levels are available: Numo::GSL::PREC_DOUBLE, Numo::GSL::PREC_SINGLE, Numo::GSL::PREC_APPROX.
+  @return [DFloat]   result
+
+  <%= description %>
+*/
+static VALUE
+<%=c_func(-1)%>(int argc, VALUE *v, VALUE mod)
+{
+    ndfunc_arg_in_t ain[1] = {{cDF,0}};
+    ndfunc_arg_out_t aout[1] = {{cDF,0}};
+    ndfunc_t ndf = {iter_<%=c_func%>, STRIDE_LOOP|NDF_EXTRACT, 1,1, ain,aout};
+    gsl_mode_t c1;
+
+    if (argc==1) {
+        c1 = GSL_MODE_DEFAULT;
+    } else if (argc==2) {
+        c1 = NUM2INT(v[1]);
+    } else {
+        rb_raise(rb_eArgError,"invalid number of argument: %d for 1..2",argc);
+    }
+    return na_ndloop3(&ndf, &c1, 1, v[0]);
+}