ruby-dcl 1.6.2

data/math1_maplib.c

@@ -0,0 +1,172 @@
+/*
+ * $Id: p_header,v 1.2 2011-02-23 17:47:10 koshiro Exp $
+ */
+
+#include <stdio.h>
+#include "ruby.h"
+#include "libtinyf2c.h"
+#include "narray.h"
+
+/* for compatibility with ruby 1.6 */
+#ifndef StringValuePtr
+#define StringValuePtr(s) STR2CSTR(s)
+#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 real */
+/* fnclib */
+extern real rd2r_(real *);
+extern real rr2d_(real *);
+extern real rexp_(real *, integer *, integer *);
+extern real rfpi_(void);
+extern real rmod_(real *, real *);
+/* gnmlib */
+extern real rgnlt_(real *);
+extern real rgnle_(real *);
+extern real rgngt_(real *);
+extern real rgnge_(real *);
+/* rfalib */
+extern real rmax_(real *, integer *, integer *);
+extern real rmin_(real *, integer *, integer *);
+extern real rsum_(real *, integer *, integer *);
+extern real rave_(real *, integer *, integer *);
+extern real rvar_(real *, integer *, integer *);
+extern real rstd_(real *, integer *, integer *);
+extern real rrms_(real *, integer *, integer *);
+extern real ramp_(real *, integer *, integer *);
+/* rfblib */
+extern real rprd_(real *, real *, integer *, integer *, integer *);
+extern real rcov_(real *, real *, integer *, integer *, integer *);
+extern real rcor_(real *, real *, integer *, integer *, integer *);
+
+
+extern VALUE mDCL;
+
+static VALUE
+dcl_mpscon(obj, ylat0)
+    VALUE obj, ylat0;
+{
+    real i_ylat0;
+
+    if (TYPE(ylat0) != T_FLOAT) {
+      ylat0 = rb_funcall(ylat0, rb_intern("to_f"), 0);
+    }
+
+    i_ylat0 = (real)NUM2DBL(ylat0);
+
+
+    mpscon_(&i_ylat0);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_mpscoa(obj, ylat1)
+    VALUE obj, ylat1;
+{
+    real i_ylat1;
+
+    if (TYPE(ylat1) != T_FLOAT) {
+      ylat1 = rb_funcall(ylat1, rb_intern("to_f"), 0);
+    }
+
+    i_ylat1 = (real)NUM2DBL(ylat1);
+
+
+    mpscoa_(&i_ylat1);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_mpscoc(obj, ylat1, ylat2)
+    VALUE obj, ylat1, ylat2;
+{
+    real i_ylat1;
+    real i_ylat2;
+
+    if (TYPE(ylat1) != T_FLOAT) {
+      ylat1 = rb_funcall(ylat1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ylat2) != T_FLOAT) {
+      ylat2 = rb_funcall(ylat2, rb_intern("to_f"), 0);
+    }
+
+    i_ylat1 = (real)NUM2DBL(ylat1);
+    i_ylat2 = (real)NUM2DBL(ylat2);
+
+
+    mpscoc_(&i_ylat1, &i_ylat2);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_mpsbon(obj, ylat1)
+    VALUE obj, ylat1;
+{
+    real i_ylat1;
+
+    if (TYPE(ylat1) != T_FLOAT) {
+      ylat1 = rb_funcall(ylat1, rb_intern("to_f"), 0);
+    }
+
+    i_ylat1 = (real)NUM2DBL(ylat1);
+
+
+    mpsbon_(&i_ylat1);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_mpsotg(obj, rsat)
+    VALUE obj, rsat;
+{
+    real i_rsat;
+
+    if (TYPE(rsat) != T_FLOAT) {
+      rsat = rb_funcall(rsat, rb_intern("to_f"), 0);
+    }
+
+    i_rsat = (real)NUM2DBL(rsat);
+
+
+    mpsotg_(&i_rsat);
+
+    return Qnil;
+
+}
+void
+init_math1_maplib(mDCL)
+VALUE mDCL;
+{
+    rb_define_module_function(mDCL, "mpscon", dcl_mpscon, 1);
+    rb_define_module_function(mDCL, "mpscoa", dcl_mpscoa, 1);
+    rb_define_module_function(mDCL, "mpscoc", dcl_mpscoc, 2);
+    rb_define_module_function(mDCL, "mpsbon", dcl_mpsbon, 1);
+    rb_define_module_function(mDCL, "mpsotg", dcl_mpsotg, 1);
+}

data/math1_oslib.c

@@ -0,0 +1,111 @@
+/*
+ * $Id: p_header,v 1.2 2011-02-23 17:47:10 koshiro Exp $
+ */
+
+#include <stdio.h>
+#include "ruby.h"
+#include "libtinyf2c.h"
+#include "narray.h"
+
+/* for compatibility with ruby 1.6 */
+#ifndef StringValuePtr
+#define StringValuePtr(s) STR2CSTR(s)
+#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 real */
+/* fnclib */
+extern real rd2r_(real *);
+extern real rr2d_(real *);
+extern real rexp_(real *, integer *, integer *);
+extern real rfpi_(void);
+extern real rmod_(real *, real *);
+/* gnmlib */
+extern real rgnlt_(real *);
+extern real rgnle_(real *);
+extern real rgngt_(real *);
+extern real rgnge_(real *);
+/* rfalib */
+extern real rmax_(real *, integer *, integer *);
+extern real rmin_(real *, integer *, integer *);
+extern real rsum_(real *, integer *, integer *);
+extern real rave_(real *, integer *, integer *);
+extern real rvar_(real *, integer *, integer *);
+extern real rstd_(real *, integer *, integer *);
+extern real rrms_(real *, integer *, integer *);
+extern real ramp_(real *, integer *, integer *);
+/* rfblib */
+extern real rprd_(real *, real *, integer *, integer *, integer *);
+extern real rcov_(real *, real *, integer *, integer *, integer *);
+extern real rcor_(real *, real *, integer *, integer *, integer *);
+
+
+extern VALUE mDCL;
+
+static VALUE
+dcl_osqarn(obj)
+    VALUE obj;
+{
+    integer o_n;
+    VALUE n;
+
+    osqarn_(&o_n);
+
+    n = INT2NUM(o_n);
+
+
+    return n;
+
+}
+
+static VALUE
+dcl_osgarg(obj, n)
+    VALUE obj, n;
+{
+    integer i_n;
+    char *o_chr;
+    VALUE chr;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+
+    o_chr= ALLOCA_N(char, (DFLT_SIZE+1));
+    memset(o_chr, '\0', DFLT_SIZE+1);
+
+    osgarg_(&i_n, o_chr, (ftnlen)DFLT_SIZE);
+
+    chr = rb_str_new2(o_chr);
+
+
+    return chr;
+
+}
+void
+init_math1_oslib(mDCL)
+VALUE mDCL;
+{
+    rb_define_module_function(mDCL, "osqarn", dcl_osqarn, 0);
+    rb_define_module_function(mDCL, "osgarg", dcl_osgarg, 1);
+}

data/math1_rfalib.c

@@ -0,0 +1,1417 @@
+/*
+ * $Id: p_header,v 1.2 2011-02-23 17:47:10 koshiro Exp $
+ */
+
+#include <stdio.h>
+#include "ruby.h"
+#include "libtinyf2c.h"
+#include "narray.h"
+
+/* for compatibility with ruby 1.6 */
+#ifndef StringValuePtr
+#define StringValuePtr(s) STR2CSTR(s)
+#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 real */
+/* fnclib */
+extern real rd2r_(real *);
+extern real rr2d_(real *);
+extern real rexp_(real *, integer *, integer *);
+extern real rfpi_(void);
+extern real rmod_(real *, real *);
+/* gnmlib */
+extern real rgnlt_(real *);
+extern real rgnle_(real *);
+extern real rgngt_(real *);
+extern real rgnge_(real *);
+/* rfalib */
+extern real rmax_(real *, integer *, integer *);
+extern real rmin_(real *, integer *, integer *);
+extern real rsum_(real *, integer *, integer *);
+extern real rave_(real *, integer *, integer *);
+extern real rvar_(real *, integer *, integer *);
+extern real rstd_(real *, integer *, integer *);
+extern real rrms_(real *, integer *, integer *);
+extern real ramp_(real *, integer *, integer *);
+/* rfblib */
+extern real rprd_(real *, real *, integer *, integer *, integer *);
+extern real rcov_(real *, real *, integer *, integer *, integer *);
+extern real rcor_(real *, real *, integer *, integer *, integer *);
+
+
+extern VALUE mDCL;
+
+static VALUE
+dcl_rmax(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rmax_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rmax0(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rmax0_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rmax1(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rmax1_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rmin(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rmin_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rmin0(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rmin0_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rmin1(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rmin1_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rsum(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rsum_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rsum0(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rsum0_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rsum1(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rsum1_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rave(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rave_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rave0(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rave0_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rave1(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rave1_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rvar(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rvar_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rvar0(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rvar0_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rvar1(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rvar1_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rstd(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rstd_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rstd0(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rstd0_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rstd1(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rstd1_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rrms(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rrms_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rrms0(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rrms0_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rrms1(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = rrms1_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_ramp(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = ramp_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_ramp0(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = ramp0_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_ramp1(obj, rx, n, jx)
+    VALUE obj, rx, n, jx;
+{
+    real *i_rx;
+    integer i_n;
+    integer i_jx;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(jx) != T_BIGNUM) || (TYPE(jx) != T_FIXNUM)) {
+      jx = rb_funcall(jx, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_jx = NUM2INT(jx);
+    i_rx = dcl_obj2crealary(rx);
+
+
+    o_rtn_val = ramp1_(i_rx, &i_n, &i_jx);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rvmax(obj, rx, ns, np, nq, nd)
+    VALUE obj, rx, ns, np, nq, nd;
+{
+    real *i_rx;
+    integer *i_ns;
+    integer *i_np;
+    integer *i_nq;
+    integer i_nd;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(ns) == T_BIGNUM) || (TYPE(ns) == T_FIXNUM)) {
+      ns = rb_Array(ns);
+    }
+    /* if ((TYPE(ns) != T_ARRAY) && 
+           (rb_obj_is_kind_of(ns, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(np) == T_BIGNUM) || (TYPE(np) == T_FIXNUM)) {
+      np = rb_Array(np);
+    }
+    /* if ((TYPE(np) != T_ARRAY) && 
+           (rb_obj_is_kind_of(np, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(nq) == T_BIGNUM) || (TYPE(nq) == T_FIXNUM)) {
+      nq = rb_Array(nq);
+    }
+    /* if ((TYPE(nq) != T_ARRAY) && 
+           (rb_obj_is_kind_of(nq, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(nd) != T_BIGNUM) || (TYPE(nd) != T_FIXNUM)) {
+      nd = rb_funcall(nd, rb_intern("to_i"), 0);
+    }
+
+    i_nd = NUM2INT(nd);
+    i_rx = dcl_obj2crealary(rx);
+    i_ns = dcl_obj2cintegerary(ns);
+    i_np = dcl_obj2cintegerary(np);
+    i_nq = dcl_obj2cintegerary(nq);
+
+
+    o_rtn_val = rvmax_(i_rx, i_ns, i_np, i_nq, &i_nd);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+    dcl_freecintegerary(i_ns);
+    dcl_freecintegerary(i_np);
+    dcl_freecintegerary(i_nq);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rvmax0(obj, rx, ns, np, nq, nd)
+    VALUE obj, rx, ns, np, nq, nd;
+{
+    real *i_rx;
+    integer *i_ns;
+    integer *i_np;
+    integer *i_nq;
+    integer i_nd;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(ns) == T_BIGNUM) || (TYPE(ns) == T_FIXNUM)) {
+      ns = rb_Array(ns);
+    }
+    /* if ((TYPE(ns) != T_ARRAY) && 
+           (rb_obj_is_kind_of(ns, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(np) == T_BIGNUM) || (TYPE(np) == T_FIXNUM)) {
+      np = rb_Array(np);
+    }
+    /* if ((TYPE(np) != T_ARRAY) && 
+           (rb_obj_is_kind_of(np, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(nq) == T_BIGNUM) || (TYPE(nq) == T_FIXNUM)) {
+      nq = rb_Array(nq);
+    }
+    /* if ((TYPE(nq) != T_ARRAY) && 
+           (rb_obj_is_kind_of(nq, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(nd) != T_BIGNUM) || (TYPE(nd) != T_FIXNUM)) {
+      nd = rb_funcall(nd, rb_intern("to_i"), 0);
+    }
+
+    i_nd = NUM2INT(nd);
+    i_rx = dcl_obj2crealary(rx);
+    i_ns = dcl_obj2cintegerary(ns);
+    i_np = dcl_obj2cintegerary(np);
+    i_nq = dcl_obj2cintegerary(nq);
+
+
+    o_rtn_val = rvmax0_(i_rx, i_ns, i_np, i_nq, &i_nd);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+    dcl_freecintegerary(i_ns);
+    dcl_freecintegerary(i_np);
+    dcl_freecintegerary(i_nq);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rvmin(obj, rx, ns, np, nq, nd)
+    VALUE obj, rx, ns, np, nq, nd;
+{
+    real *i_rx;
+    integer *i_ns;
+    integer *i_np;
+    integer *i_nq;
+    integer i_nd;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(ns) == T_BIGNUM) || (TYPE(ns) == T_FIXNUM)) {
+      ns = rb_Array(ns);
+    }
+    /* if ((TYPE(ns) != T_ARRAY) && 
+           (rb_obj_is_kind_of(ns, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(np) == T_BIGNUM) || (TYPE(np) == T_FIXNUM)) {
+      np = rb_Array(np);
+    }
+    /* if ((TYPE(np) != T_ARRAY) && 
+           (rb_obj_is_kind_of(np, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(nq) == T_BIGNUM) || (TYPE(nq) == T_FIXNUM)) {
+      nq = rb_Array(nq);
+    }
+    /* if ((TYPE(nq) != T_ARRAY) && 
+           (rb_obj_is_kind_of(nq, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(nd) != T_BIGNUM) || (TYPE(nd) != T_FIXNUM)) {
+      nd = rb_funcall(nd, rb_intern("to_i"), 0);
+    }
+
+    i_nd = NUM2INT(nd);
+    i_rx = dcl_obj2crealary(rx);
+    i_ns = dcl_obj2cintegerary(ns);
+    i_np = dcl_obj2cintegerary(np);
+    i_nq = dcl_obj2cintegerary(nq);
+
+
+    o_rtn_val = rvmin_(i_rx, i_ns, i_np, i_nq, &i_nd);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+    dcl_freecintegerary(i_ns);
+    dcl_freecintegerary(i_np);
+    dcl_freecintegerary(i_nq);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rvmax1(obj, rx, ns, np, nq, nd)
+    VALUE obj, rx, ns, np, nq, nd;
+{
+    real *i_rx;
+    integer *i_ns;
+    integer *i_np;
+    integer *i_nq;
+    integer i_nd;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(ns) == T_BIGNUM) || (TYPE(ns) == T_FIXNUM)) {
+      ns = rb_Array(ns);
+    }
+    /* if ((TYPE(ns) != T_ARRAY) && 
+           (rb_obj_is_kind_of(ns, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(np) == T_BIGNUM) || (TYPE(np) == T_FIXNUM)) {
+      np = rb_Array(np);
+    }
+    /* if ((TYPE(np) != T_ARRAY) && 
+           (rb_obj_is_kind_of(np, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(nq) == T_BIGNUM) || (TYPE(nq) == T_FIXNUM)) {
+      nq = rb_Array(nq);
+    }
+    /* if ((TYPE(nq) != T_ARRAY) && 
+           (rb_obj_is_kind_of(nq, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(nd) != T_BIGNUM) || (TYPE(nd) != T_FIXNUM)) {
+      nd = rb_funcall(nd, rb_intern("to_i"), 0);
+    }
+
+    i_nd = NUM2INT(nd);
+    i_rx = dcl_obj2crealary(rx);
+    i_ns = dcl_obj2cintegerary(ns);
+    i_np = dcl_obj2cintegerary(np);
+    i_nq = dcl_obj2cintegerary(nq);
+
+
+    o_rtn_val = rvmax1_(i_rx, i_ns, i_np, i_nq, &i_nd);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+    dcl_freecintegerary(i_ns);
+    dcl_freecintegerary(i_np);
+    dcl_freecintegerary(i_nq);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rvmin1(obj, rx, ns, np, nq, nd)
+    VALUE obj, rx, ns, np, nq, nd;
+{
+    real *i_rx;
+    integer *i_ns;
+    integer *i_np;
+    integer *i_nq;
+    integer i_nd;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(ns) == T_BIGNUM) || (TYPE(ns) == T_FIXNUM)) {
+      ns = rb_Array(ns);
+    }
+    /* if ((TYPE(ns) != T_ARRAY) && 
+           (rb_obj_is_kind_of(ns, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(np) == T_BIGNUM) || (TYPE(np) == T_FIXNUM)) {
+      np = rb_Array(np);
+    }
+    /* if ((TYPE(np) != T_ARRAY) && 
+           (rb_obj_is_kind_of(np, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(nq) == T_BIGNUM) || (TYPE(nq) == T_FIXNUM)) {
+      nq = rb_Array(nq);
+    }
+    /* if ((TYPE(nq) != T_ARRAY) && 
+           (rb_obj_is_kind_of(nq, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(nd) != T_BIGNUM) || (TYPE(nd) != T_FIXNUM)) {
+      nd = rb_funcall(nd, rb_intern("to_i"), 0);
+    }
+
+    i_nd = NUM2INT(nd);
+    i_rx = dcl_obj2crealary(rx);
+    i_ns = dcl_obj2cintegerary(ns);
+    i_np = dcl_obj2cintegerary(np);
+    i_nq = dcl_obj2cintegerary(nq);
+
+
+    o_rtn_val = rvmin1_(i_rx, i_ns, i_np, i_nq, &i_nd);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+    dcl_freecintegerary(i_ns);
+    dcl_freecintegerary(i_np);
+    dcl_freecintegerary(i_nq);
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_rvmin0(obj, rx, ns, np, nq, nd)
+    VALUE obj, rx, ns, np, nq, nd;
+{
+    real *i_rx;
+    integer *i_ns;
+    integer *i_np;
+    integer *i_nq;
+    integer i_nd;
+    real o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(rx) == T_FLOAT) {
+      rx = rb_Array(rx);
+    }
+    /* if ((TYPE(rx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(ns) == T_BIGNUM) || (TYPE(ns) == T_FIXNUM)) {
+      ns = rb_Array(ns);
+    }
+    /* if ((TYPE(ns) != T_ARRAY) && 
+           (rb_obj_is_kind_of(ns, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(np) == T_BIGNUM) || (TYPE(np) == T_FIXNUM)) {
+      np = rb_Array(np);
+    }
+    /* if ((TYPE(np) != T_ARRAY) && 
+           (rb_obj_is_kind_of(np, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(nq) == T_BIGNUM) || (TYPE(nq) == T_FIXNUM)) {
+      nq = rb_Array(nq);
+    }
+    /* if ((TYPE(nq) != T_ARRAY) && 
+           (rb_obj_is_kind_of(nq, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(nd) != T_BIGNUM) || (TYPE(nd) != T_FIXNUM)) {
+      nd = rb_funcall(nd, rb_intern("to_i"), 0);
+    }
+
+    i_nd = NUM2INT(nd);
+    i_rx = dcl_obj2crealary(rx);
+    i_ns = dcl_obj2cintegerary(ns);
+    i_np = dcl_obj2cintegerary(np);
+    i_nq = dcl_obj2cintegerary(nq);
+
+
+    o_rtn_val = rvmin0_(i_rx, i_ns, i_np, i_nq, &i_nd);
+
+    rtn_val = rb_float_new((double)o_rtn_val);
+
+    dcl_freecrealary(i_rx);
+    dcl_freecintegerary(i_ns);
+    dcl_freecintegerary(i_np);
+    dcl_freecintegerary(i_nq);
+
+    return rtn_val;
+
+}
+void
+init_math1_rfalib(mDCL)
+VALUE mDCL;
+{
+    rb_define_module_function(mDCL, "rmax", dcl_rmax, 3);
+    rb_define_module_function(mDCL, "rmax0", dcl_rmax0, 3);
+    rb_define_module_function(mDCL, "rmax1", dcl_rmax1, 3);
+    rb_define_module_function(mDCL, "rmin", dcl_rmin, 3);
+    rb_define_module_function(mDCL, "rmin0", dcl_rmin0, 3);
+    rb_define_module_function(mDCL, "rmin1", dcl_rmin1, 3);
+    rb_define_module_function(mDCL, "rsum", dcl_rsum, 3);
+    rb_define_module_function(mDCL, "rsum0", dcl_rsum0, 3);
+    rb_define_module_function(mDCL, "rsum1", dcl_rsum1, 3);
+    rb_define_module_function(mDCL, "rave", dcl_rave, 3);
+    rb_define_module_function(mDCL, "rave0", dcl_rave0, 3);
+    rb_define_module_function(mDCL, "rave1", dcl_rave1, 3);
+    rb_define_module_function(mDCL, "rvar", dcl_rvar, 3);
+    rb_define_module_function(mDCL, "rvar0", dcl_rvar0, 3);
+    rb_define_module_function(mDCL, "rvar1", dcl_rvar1, 3);
+    rb_define_module_function(mDCL, "rstd", dcl_rstd, 3);
+    rb_define_module_function(mDCL, "rstd0", dcl_rstd0, 3);
+    rb_define_module_function(mDCL, "rstd1", dcl_rstd1, 3);
+    rb_define_module_function(mDCL, "rrms", dcl_rrms, 3);
+    rb_define_module_function(mDCL, "rrms0", dcl_rrms0, 3);
+    rb_define_module_function(mDCL, "rrms1", dcl_rrms1, 3);
+    rb_define_module_function(mDCL, "ramp", dcl_ramp, 3);
+    rb_define_module_function(mDCL, "ramp0", dcl_ramp0, 3);
+    rb_define_module_function(mDCL, "ramp1", dcl_ramp1, 3);
+    rb_define_module_function(mDCL, "rvmax", dcl_rvmax, 5);
+    rb_define_module_function(mDCL, "rvmax0", dcl_rvmax0, 5);
+    rb_define_module_function(mDCL, "rvmin", dcl_rvmin, 5);
+    rb_define_module_function(mDCL, "rvmax1", dcl_rvmax1, 5);
+    rb_define_module_function(mDCL, "rvmin1", dcl_rvmin1, 5);
+    rb_define_module_function(mDCL, "rvmin0", dcl_rvmin0, 5);
+}