ruby-dcl 1.6.2

data/README

@@ -0,0 +1,29 @@
+
+	     RubyDCL -- a ruby interface to the DCL library
+
+	 by T. Horinouchi, K. Goto, and K. Kuroi, T Koshiro
+
+Last Updated: Feb 24, 2011 by T Horinouchi
+
+* WHAT IS THIS?
+
+  This is a one-to-one wrapper to a scientific graphic library DCL
+  (http://www.gfd-dennou.org/arch/dcl/).
+
+* DOCUMENTATION
+
+  Documentation of this library is distributed sepately, since it is
+  very big. You can download it from the following addresses.
+
+    Jappanese Documentation:
+      http://ruby.gfd-dennou.org/products/ruby-dcl/ruby-dcl-doc.tar.gz
+    English Documentation:
+      http://ruby.gfd-dennou.org/products/ruby-dcl/ruby-dcl-Edoc.tar.gz
+
+  The documentation is available on the web:
+
+      http://ruby.gfd-dennou.org/products/ruby-dcl/
+
+* INSTALLATION (dependent software)
+
+  See http://ruby.gfd-dennou.org/products/ruby-dcl/#installation

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rake/gempackagetask'
+
+NAME = 'ruby-dcl'
+VER = '1.6.2'
+
+PKG_FILES = FileList[
+  '**',
+  'lib/**',
+  'GenWrapper/**/**',
+  'obsolete/**',
+  'demo/**/**'
+]
+#gem_load_dir = Gem.default_dir
+
+spec = Gem::Specification.new do |s|
+  s.name             = NAME
+  s.version          = VER
+  s.authors          = ["T. Horinouchi", "K. Kuroi", "K. Goto"\
+    ,"S. Nishizawa", "T. Koshiro",'GFD Dennou Club']
+  s.email            = 'eriko@gfd-dennou.org'
+  s.homepage         = \
+    'http://www.gfd-dennou.org/arch/ruby/products/ruby-dcl/'
+  s.licenses         = ["GFD Dennou Club"]
+  s.platform         = Gem::Platform::RUBY
+  s.summary          = 'one-to-one interface to the DCL graphic library'
+  s.description      = 'RubyDCL is a ruby interface to the scientific graphic library DCL. It supports all the subroutines and functions in DCL on a one-to-one basis. '
+  s.files            = PKG_FILES.to_a
+  s.require_paths    = ['lib']
+  #s.test_files = Dir.glob("test/*")
+  s.has_rdoc         = true
+  s.required_ruby_version = Gem::Requirement.new(">= 1.6")
+  s.add_runtime_dependency(%q<narray>, [">= 0.5.5"])
+  s.add_runtime_dependency(%q<narray_miss>, [">= 0"])
+  s.add_runtime_dependency(%q<gtk2>, [">= 0"])
+  #s.extra_rdoc_files = ['README']
+
+  #-- extensions
+  s.extensions << "extconf.rb"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+  pkg.need_tar = true
+end

data/ToDo

@@ -0,0 +1,2 @@
+Mon May 13  2002  T Horinouchi
+* nil => rundef �̓ǂݑւ��� dcl_raw ���x���ł�肽���B

data/dcl_cary2obj.c

@@ -0,0 +1,354 @@
+/*
+ * dcl_cary2obj.c
+ *   $Id: dcl_cary2obj.c,v 1.1.1.1 2011-02-23 07:21:26 horinout Exp $
+ */
+
+#include <math.h>
+#include "ruby.h"
+#include "libtinyf2c.h"
+#include "narray.h"  /* kuro: depend on numarray.so */
+
+
+/*  functions  */
+VALUE dcl_ccharary2obj(char *, int, int);
+VALUE dcl_cintegerary2obj(integer *, int, int, int *);
+VALUE dcl_crealary2obj(real *, int, int, int *);
+VALUE dcl_ccomplexary2obj(complex *, int, char *);
+VALUE dcl_clogicalary2obj(logical *, int, int, int *);
+
+static VALUE ccharary2ary(char *, int, int);
+static VALUE cintegerary2ary(integer *, int);
+static VALUE crealary2ary(real *, int);
+static VALUE clogicalary2ary(logical *, int);
+/* not inplemented
+static VALUE ccomplexary2ary(complex *, int);
+*/
+
+/* kuro: depend on numarray.so */
+static VALUE crealary2na(real *, int, int, int *);
+static VALUE clogicalary2na(logical *, int, int, int *);
+static VALUE cintegerary2na(integer *, int, int, int *);
+/* not implemented
+static VALUE ccomplexary2na(complex *, int, char *);
+*/
+
+
+/*
+ * dcl_cxxxary2obj() : convert c xxx type array to ruby object
+ *   dcl_ccharary2obj()
+ *   dcl_cintegerary2obj()
+ *   dcl_crealary2obj()
+ *   dcl_ccomplexary2obj() : not implemented
+ *   dcl_clogicalary2obj()
+ */
+VALUE
+dcl_ccharary2obj(cary, size, len)
+    char *cary;
+    int size;
+    int len;
+{
+    VALUE obj;
+
+    obj = ccharary2ary(cary, size, len);
+
+    return obj;
+}
+
+VALUE
+dcl_cintegerary2obj(cary, size, rank, shape)
+    integer *cary;
+    int size;
+    int rank;
+    int *shape;
+{
+    VALUE obj;
+
+    /* if ( rank == 1 ) {
+	obj = cintegerary2ary(cary, size);
+    } else { */
+	obj = cintegerary2na(cary, size, rank, shape);
+    /*}*/
+
+    return obj;
+}
+
+VALUE
+dcl_crealary2obj(cary, size, rank, shape)
+    real *cary;
+    int size;
+    int rank;
+    int *shape;
+{
+    VALUE obj;
+
+    /* if ( rank == 1 ) {
+	obj = crealary2ary(cary, size);
+    } else { */
+	obj = crealary2na(cary, size, rank, shape);
+    /*}*/
+
+    return obj;
+}
+
+/* not implemented
+VALUE
+dcl_ccomplexary2obj(cary, size, type)
+    complex *cary;
+    int size;
+    char *type;
+{
+    VALUE obj;
+
+    if ((type == NULL) || ( *type == '\0' )) {
+	obj = ccomplexary2ary(cary, size);
+    } else {
+	obj = ccomplexary2na(cary, size, type);
+    }
+
+    return obj;
+}
+*/
+
+VALUE
+dcl_clogicalary2obj(cary, size, rank, shape)
+    logical *cary;
+    int size;
+    int rank;
+    int *shape;
+{
+    VALUE obj;
+
+    obj = clogicalary2ary(cary, size);
+
+    /*if ( rank == 0) {
+	obj = clogicalary2ary(cary, size);
+    } else {*/
+	obj = clogicalary2na(cary, size, rank, shape);
+    /*}*/
+    
+    return obj;
+}
+
+
+/*
+ *  cxxxary2ary() : convert c xxx type array to Array object
+ *                  called by cxxxary2obj()
+ *   ccharary2ary()
+ *   cintegerary2ary()
+ *   crealary2ary()
+ *   ccomplexary2ary() : not implemented
+ *   clogicalary2ary()
+ */
+static VALUE
+ccharary2ary(cary, size, len)
+    char *cary;
+    int size;
+    int len;
+{
+    VALUE obj, item;
+    char *buf, *hd, *ed;
+    int i, j;
+
+    if (cary == NULL)
+	rb_raise(rb_eRuntimeError, "cannot create Array");
+
+    obj = rb_ary_new2(size/len);
+    buf = ALLOCA_N(char, len+1);
+    hd = cary;
+    for (i = 0; i < size/len; i++) {
+        j = len - 1;
+        ed = hd + j;
+        while ((j >= 0) && (*ed == ' ' || *ed == '\0')) {
+            ed--;
+            j--;
+        }
+        if (j >= 0) memcpy(buf, hd, j+1);
+        buf[j+1] = '\0';
+        item = rb_str_new2(buf);
+        rb_ary_push(obj, item);
+        hd += len;
+    }
+
+    return obj;
+}
+
+static VALUE
+cintegerary2ary(cary, size)
+    integer *cary;
+    int size;
+{
+    VALUE obj, item;
+    int i;
+
+    if (cary == NULL)
+	rb_raise(rb_eRuntimeError, "cannot create Array");
+
+    obj = rb_ary_new2(size);
+
+    for (i = 0; i < size; i++) {
+        item = INT2NUM(cary[i]);
+	rb_ary_push(obj, item);
+    }
+
+    return obj;
+}
+
+static VALUE
+crealary2ary(cary, size)
+    real *cary;
+    int size;
+{
+    VALUE obj, item;
+    int i;
+
+    if (cary == NULL)
+	rb_raise(rb_eRuntimeError, "cannot create Array");
+
+    obj = rb_ary_new2(size);
+
+    for (i = 0; i < size; i++) {
+	item = rb_float_new((double)cary[i]);
+	rb_ary_push(obj, item);
+    }
+
+    return obj;
+}
+
+/* not inplemented
+static VALUE
+ccomplexary2ary(cary, size)
+    complex *cary;
+    int size;
+{
+    VALUE obj, item;
+    int i;
+
+    if (cary == NULL)
+	rb_raise(rb_eRuntimeError, "cannot create Array");
+
+    obj = rb_ary_new2(size);
+
+    for (i = 0; i < size; i++) {
+	item = ... cary[i];
+	rb_ary_push(obj, item);
+    }
+
+    return obj;
+}
+*/
+
+static VALUE
+clogicalary2ary(cary, size)
+    logical *cary;
+    int size;
+{
+    VALUE obj, item;
+    int i;
+
+    if (cary == NULL)
+	rb_raise(rb_eRuntimeError, "cannot create Array");
+
+    obj = rb_ary_new2(size);
+
+    for (i = 0; i < size; i++) {
+	item = (cary[i] == FALSE_) ? Qfalse : Qtrue;
+	rb_ary_push(obj, item);
+    }
+
+    return obj;
+}
+
+
+/* kuro: depend on numarray.so */
+/*
+ *  cxxxary2na() : convert c xxx type array to NumArray object
+ *                 called by cxxxary2obj()
+ *   cintegerary2na() : not implemented
+ *   crealary2na()
+ *   ccomplexary2na() : not implemented
+ *   clogicalary2na()
+ */
+static VALUE
+crealary2na(cary, size, rank, shape)
+    real *cary;
+    int size;
+    int rank;
+    int *shape;
+{
+    VALUE obj;
+    struct NARRAY *na;
+    int i;
+    float *ptr;
+
+    if (cary == NULL)
+	rb_raise(rb_eRuntimeError, "cannot create NArray");
+    if (rank <= 0)
+	rb_raise(rb_eRuntimeError, "cannot create NArray");
+
+    obj = na_make_object(NA_SFLOAT, rank, shape, cNArray);
+    GetNArray(obj, na);
+    ptr = (float *) NA_PTR(na, 0);
+
+    for (i = 0; i < size; i++) {
+	ptr[i] = (float)cary[i];
+    }
+
+    return obj;
+}
+
+static VALUE
+cintegerary2na(cary, size, rank, shape)
+    integer *cary;
+    int size;
+    int rank;
+    int *shape;
+{
+    VALUE obj;
+    struct NARRAY *na;
+    int i;
+    int32_t *ptr;
+
+    if (cary == NULL)
+	rb_raise(rb_eRuntimeError, "cannot create NArray");
+    if (rank <= 0)
+	rb_raise(rb_eRuntimeError, "cannot create NArray");
+
+    obj = na_make_object(NA_LINT, rank, shape, cNArray);
+    GetNArray(obj, na);
+    ptr = (int32_t *) NA_PTR(na, 0);
+
+    for (i = 0; i < size; i++) {
+	ptr[i] = (int32_t)cary[i];
+    }
+
+    return obj;
+}
+
+static VALUE
+clogicalary2na(cary, size, rank, shape)
+    logical *cary;
+    int size;
+    int rank;
+    int *shape;
+{
+    VALUE obj;
+    struct NARRAY *na;
+    int i;
+    u_int8_t *ptr;
+
+    if (cary == NULL)
+	rb_raise(rb_eRuntimeError, "cannot create NumArray");
+    if (rank <= 0)
+	rb_raise(rb_eRuntimeError, "cannot create NArray");
+
+    obj = na_make_object(NA_BYTE, rank, shape, cNArray);
+    GetNArray(obj, na);
+    ptr = (u_int8_t *) NA_PTR(na, 0);
+
+    for (i = 0; i < size; i++) {
+	ptr[i] = (u_int8_t)cary[i];
+    }
+
+    return obj;
+}
+

data/dcl_narrayed_funcs.c

@@ -0,0 +1,518 @@
+
+/*
+ * Original methods of Ruby-DCL
+ *
+ * Alert: DO NOT EDIT THIS FILE!!!
+ *   This file was automatically generated by GenWrapper/dcl_narray_funcs.rb 
+ */
+
+#include <stdio.h>
+#include "ruby.h"
+#include "libtinyf2c.h"
+#include "narray.h"
+
+#ifndef RARRAY_LEN
+#  define RARRAY_LEN(ary) (RARRAY(ary)->len)
+#endif
+
+#define DFLT_SIZE 32
+
+extern char    *dcl_obj2ccharary(VALUE, int, int);
+extern integer *dcl_obj2cintegerary(VALUE);
+extern real    *dcl_obj2crealary(VALUE);
+extern complex *dcl_obj2ccomplexary(VALUE);
+extern logical *dcl_obj2clogicalary(VALUE);
+
+extern VALUE dcl_ccharary2obj(char *, int, int);
+extern VALUE dcl_cintegerary2obj(integer *, int, int, int *);
+extern VALUE dcl_crealary2obj(real *, int, int, int *);
+extern VALUE dcl_ccomplexary2obj(complex *, int, char *);
+extern VALUE dcl_clogicalary2obj(logical *, int, int, int *);
+
+extern void dcl_freeccharary(char *);
+extern void dcl_freecintegerary(integer *);
+extern void dcl_freecrealary(real *);
+extern void dcl_freeccomplexary(complex *);
+extern void dcl_freeclogicalary(logical *);
+
+/* for functions which return doublereal */
+/* fnclib */
+extern doublereal rd2r_(real *);
+extern doublereal rr2d_(real *);
+extern doublereal rexp_(real *, integer *, integer *);
+extern doublereal rfpi_(void);
+extern doublereal rmod_(real *, real *);
+/* gnmlib */
+extern doublereal rgnlt_(real *);
+extern doublereal rgnle_(real *);
+extern doublereal rgngt_(real *);
+extern doublereal rgnge_(real *);
+/* rfalib */
+extern doublereal rmax_(real *, integer *, integer *);
+extern doublereal rmin_(real *, integer *, integer *);
+extern doublereal rsum_(real *, integer *, integer *);
+extern doublereal rave_(real *, integer *, integer *);
+extern doublereal rvar_(real *, integer *, integer *);
+extern doublereal rstd_(real *, integer *, integer *);
+extern doublereal rrms_(real *, integer *, integer *);
+extern doublereal ramp_(real *, integer *, integer *);
+/* rfblib */
+extern doublereal rprd_(real *, real *, integer *, integer *, integer *);
+extern doublereal rcov_(real *, real *, integer *, integer *, integer *);
+extern doublereal rcor_(real *, real *, integer *, integer *, integer *);
+
+
+extern int stftrf_(real*,real*,real*,real*);
+
+extern int stitrf_(real*,real*,real*,real*);
+
+extern int stfpr2_(real*,real*,real*,real*);
+
+extern int stipr2_(real*,real*,real*,real*);
+
+extern int mpfcyl_(real*,real*,real*,real*);
+
+extern int mpicyl_(real*,real*,real*,real*);
+
+extern int mpfmer_(real*,real*,real*,real*);
+
+extern int mpimer_(real*,real*,real*,real*);
+
+extern int mpfmwd_(real*,real*,real*,real*);
+
+extern int mpimwd_(real*,real*,real*,real*);
+
+extern int mpfmwl_(real*,real*,real*,real*);
+
+extern int mpimwl_(real*,real*,real*,real*);
+
+extern int mpfhmr_(real*,real*,real*,real*);
+
+extern int mpihmr_(real*,real*,real*,real*);
+
+extern int mpfek6_(real*,real*,real*,real*);
+
+extern int mpiek6_(real*,real*,real*,real*);
+
+extern int mpfktd_(real*,real*,real*,real*);
+
+extern int mpiktd_(real*,real*,real*,real*);
+
+extern int mpfcon_(real*,real*,real*,real*);
+
+extern int mpicon_(real*,real*,real*,real*);
+
+extern int mpfcoa_(real*,real*,real*,real*);
+
+extern int mpicoa_(real*,real*,real*,real*);
+
+extern int mpfcoc_(real*,real*,real*,real*);
+
+extern int mpicoc_(real*,real*,real*,real*);
+
+extern int mpfbon_(real*,real*,real*,real*);
+
+extern int mpibon_(real*,real*,real*,real*);
+
+extern int mpfotg_(real*,real*,real*,real*);
+
+extern int mpiotg_(real*,real*,real*,real*);
+
+extern int mpfpst_(real*,real*,real*,real*);
+
+extern int mpipst_(real*,real*,real*,real*);
+
+extern int mpfazm_(real*,real*,real*,real*);
+
+extern int mpiazm_(real*,real*,real*,real*);
+
+extern int mpfaza_(real*,real*,real*,real*);
+
+extern int mpiaza_(real*,real*,real*,real*);
+
+extern int ct2pc_(real*,real*,real*,real*);
+
+extern int ct2cp_(real*,real*,real*,real*);
+
+extern int ct2ec_(real*,real*,real*,real*);
+
+extern int ct2bc_(real*,real*,real*,real*);
+
+extern int ct2hc_(real*,real*,real*,real*);
+
+extern int ct2ch_(real*,real*,real*,real*);
+
+
+extern VALUE mDCL;
+
+/* driver of real*2->real*2 functions such as STFTRF
+ */
+static VALUE
+dcl_rr2rr_num(obj, ux, uy, func)
+    VALUE obj, ux, uy;
+    int (*func)(real*,real*,real*,real*);
+{
+    real i_ux;
+    real i_uy;
+    real o_vx;
+    real o_vy;
+    VALUE vx;
+    VALUE vy;
+
+    if (TYPE(ux) != T_FLOAT) {
+      ux = rb_funcall(ux, rb_intern("to_f"), 0);
+    }
+    if (TYPE(uy) != T_FLOAT) {
+      uy = rb_funcall(uy, rb_intern("to_f"), 0);
+    }
+
+    i_ux = (real)NUM2DBL(ux);
+    i_uy = (real)NUM2DBL(uy);
+
+
+    (*func)(&i_ux, &i_uy, &o_vx, &o_vy);
+
+    vx = rb_float_new((double)o_vx);
+    vy = rb_float_new((double)o_vy);
+
+
+    return rb_ary_new3(2, vx, vy);
+
+}
+
+/* driver of real*2->real*2 functions such as STFTRF
+ */
+static VALUE
+dcl_rr2rr_na(obj, p, q, func)
+    VALUE obj, p, q;
+    int (*func)(real*,real*,real*,real*);
+{
+    VALUE r, s;  // return value
+    real *i_p, *i_q;
+    real *i_r, *i_s;
+    size_t len,j,lenq;
+
+    i_p = dcl_obj2crealary(p);
+    i_q = dcl_obj2crealary(q);
+    len  = (TYPE(p)==T_ARRAY) ? RARRAY_LEN(p) : NA_TOTAL(p) ;
+    lenq = (TYPE(q)==T_ARRAY) ? RARRAY_LEN(q) : NA_TOTAL(q) ;
+    if (len != lenq) {
+         rb_raise(rb_eArgError, "lengths of the 1st & 2nd args do not agree");
+    }
+
+    r = na_make_object(NA_SFLOAT, 1, &len, cNArray);
+    s = na_make_object(NA_SFLOAT, 1, &len, cNArray);
+    i_r = NA_PTR_TYPE(r,real*);
+    i_s = NA_PTR_TYPE(s,real*);
+
+    for(j=0; j<len; j++){
+	(*func)(i_p+j, i_q+j, i_r+j, i_s+j);
+    }
+
+    return rb_ary_new3(2, r, s);
+}
+
+static VALUE
+dcl_rr2rr(obj, p, q, func)
+    VALUE obj, p, q;
+    int (*func)(real*,real*,real*,real*);
+{
+    switch (TYPE(p)){
+    case T_DATA:
+    case T_ARRAY:
+	return( dcl_rr2rr_na(obj, p, q, func) );
+    default:
+	return( dcl_rr2rr_num(obj, p, q, func) );
+    }
+}
+
+
+
+static VALUE
+dcl_stftrf(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &stftrf_) );  }
+
+static VALUE
+dcl_stitrf(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &stitrf_) );  }
+
+static VALUE
+dcl_stfpr2(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &stfpr2_) );  }
+
+static VALUE
+dcl_stipr2(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &stipr2_) );  }
+
+static VALUE
+dcl_mpfcyl(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfcyl_) );  }
+
+static VALUE
+dcl_mpicyl(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpicyl_) );  }
+
+static VALUE
+dcl_mpfmer(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfmer_) );  }
+
+static VALUE
+dcl_mpimer(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpimer_) );  }
+
+static VALUE
+dcl_mpfmwd(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfmwd_) );  }
+
+static VALUE
+dcl_mpimwd(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpimwd_) );  }
+
+static VALUE
+dcl_mpfmwl(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfmwl_) );  }
+
+static VALUE
+dcl_mpimwl(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpimwl_) );  }
+
+static VALUE
+dcl_mpfhmr(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfhmr_) );  }
+
+static VALUE
+dcl_mpihmr(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpihmr_) );  }
+
+static VALUE
+dcl_mpfek6(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfek6_) );  }
+
+static VALUE
+dcl_mpiek6(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpiek6_) );  }
+
+static VALUE
+dcl_mpfktd(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfktd_) );  }
+
+static VALUE
+dcl_mpiktd(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpiktd_) );  }
+
+static VALUE
+dcl_mpfcon(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfcon_) );  }
+
+static VALUE
+dcl_mpicon(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpicon_) );  }
+
+static VALUE
+dcl_mpfcoa(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfcoa_) );  }
+
+static VALUE
+dcl_mpicoa(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpicoa_) );  }
+
+static VALUE
+dcl_mpfcoc(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfcoc_) );  }
+
+static VALUE
+dcl_mpicoc(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpicoc_) );  }
+
+static VALUE
+dcl_mpfbon(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfbon_) );  }
+
+static VALUE
+dcl_mpibon(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpibon_) );  }
+
+static VALUE
+dcl_mpfotg(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfotg_) );  }
+
+static VALUE
+dcl_mpiotg(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpiotg_) );  }
+
+static VALUE
+dcl_mpfpst(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfpst_) );  }
+
+static VALUE
+dcl_mpipst(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpipst_) );  }
+
+static VALUE
+dcl_mpfazm(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfazm_) );  }
+
+static VALUE
+dcl_mpiazm(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpiazm_) );  }
+
+static VALUE
+dcl_mpfaza(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpfaza_) );  }
+
+static VALUE
+dcl_mpiaza(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &mpiaza_) );  }
+
+static VALUE
+dcl_ct2pc(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &ct2pc_) );  }
+
+static VALUE
+dcl_ct2cp(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &ct2cp_) );  }
+
+static VALUE
+dcl_ct2ec(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &ct2ec_) );  }
+
+static VALUE
+dcl_ct2bc(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &ct2bc_) );  }
+
+static VALUE
+dcl_ct2hc(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &ct2hc_) );  }
+
+static VALUE
+dcl_ct2ch(obj, p, q)
+    VALUE obj, p, q;
+{   return( dcl_rr2rr(obj, p, q, &ct2ch_) );  }
+
+
+void
+init_narrayed_funcs(mDCL)
+VALUE mDCL;
+{
+
+    rb_define_module_function(mDCL, "stftrf", dcl_stftrf, 2);
+
+    rb_define_module_function(mDCL, "stitrf", dcl_stitrf, 2);
+
+    rb_define_module_function(mDCL, "stfpr2", dcl_stfpr2, 2);
+
+    rb_define_module_function(mDCL, "stipr2", dcl_stipr2, 2);
+
+    rb_define_module_function(mDCL, "mpfcyl", dcl_mpfcyl, 2);
+
+    rb_define_module_function(mDCL, "mpicyl", dcl_mpicyl, 2);
+
+    rb_define_module_function(mDCL, "mpfmer", dcl_mpfmer, 2);
+
+    rb_define_module_function(mDCL, "mpimer", dcl_mpimer, 2);
+
+    rb_define_module_function(mDCL, "mpfmwd", dcl_mpfmwd, 2);
+
+    rb_define_module_function(mDCL, "mpimwd", dcl_mpimwd, 2);
+
+    rb_define_module_function(mDCL, "mpfmwl", dcl_mpfmwl, 2);
+
+    rb_define_module_function(mDCL, "mpimwl", dcl_mpimwl, 2);
+
+    rb_define_module_function(mDCL, "mpfhmr", dcl_mpfhmr, 2);
+
+    rb_define_module_function(mDCL, "mpihmr", dcl_mpihmr, 2);
+
+    rb_define_module_function(mDCL, "mpfek6", dcl_mpfek6, 2);
+
+    rb_define_module_function(mDCL, "mpiek6", dcl_mpiek6, 2);
+
+    rb_define_module_function(mDCL, "mpfktd", dcl_mpfktd, 2);
+
+    rb_define_module_function(mDCL, "mpiktd", dcl_mpiktd, 2);
+
+    rb_define_module_function(mDCL, "mpfcon", dcl_mpfcon, 2);
+
+    rb_define_module_function(mDCL, "mpicon", dcl_mpicon, 2);
+
+    rb_define_module_function(mDCL, "mpfcoa", dcl_mpfcoa, 2);
+
+    rb_define_module_function(mDCL, "mpicoa", dcl_mpicoa, 2);
+
+    rb_define_module_function(mDCL, "mpfcoc", dcl_mpfcoc, 2);
+
+    rb_define_module_function(mDCL, "mpicoc", dcl_mpicoc, 2);
+
+    rb_define_module_function(mDCL, "mpfbon", dcl_mpfbon, 2);
+
+    rb_define_module_function(mDCL, "mpibon", dcl_mpibon, 2);
+
+    rb_define_module_function(mDCL, "mpfotg", dcl_mpfotg, 2);
+
+    rb_define_module_function(mDCL, "mpiotg", dcl_mpiotg, 2);
+
+    rb_define_module_function(mDCL, "mpfpst", dcl_mpfpst, 2);
+
+    rb_define_module_function(mDCL, "mpipst", dcl_mpipst, 2);
+
+    rb_define_module_function(mDCL, "mpfazm", dcl_mpfazm, 2);
+
+    rb_define_module_function(mDCL, "mpiazm", dcl_mpiazm, 2);
+
+    rb_define_module_function(mDCL, "mpfaza", dcl_mpfaza, 2);
+
+    rb_define_module_function(mDCL, "mpiaza", dcl_mpiaza, 2);
+
+    rb_define_module_function(mDCL, "ct2pc", dcl_ct2pc, 2);
+
+    rb_define_module_function(mDCL, "ct2cp", dcl_ct2cp, 2);
+
+    rb_define_module_function(mDCL, "ct2ec", dcl_ct2ec, 2);
+
+    rb_define_module_function(mDCL, "ct2bc", dcl_ct2bc, 2);
+
+    rb_define_module_function(mDCL, "ct2hc", dcl_ct2hc, 2);
+
+    rb_define_module_function(mDCL, "ct2ch", dcl_ct2ch, 2);
+
+}
+