ruby-dcl 1.6.2

data/grph1_sgpack.c

@@ -0,0 +1,3876 @@
+/*
+ * $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_sgopn(obj, iws)
+    VALUE obj, iws;
+{
+    integer i_iws;
+
+    if ((TYPE(iws) != T_BIGNUM) || (TYPE(iws) != T_FIXNUM)) {
+      iws = rb_funcall(iws, rb_intern("to_i"), 0);
+    }
+
+    i_iws = NUM2INT(iws);
+
+
+    sgopn_(&i_iws);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgfrm(obj)
+    VALUE obj;
+{
+    sgfrm_();
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgcls(obj)
+    VALUE obj;
+{
+    sgcls_();
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgpqnp(obj)
+    VALUE obj;
+{
+    integer o_ncp;
+    VALUE ncp;
+
+    sgpqnp_(&o_ncp);
+
+    ncp = INT2NUM(o_ncp);
+
+
+    return ncp;
+
+}
+
+static VALUE
+dcl_sgpqid(obj, cp)
+    VALUE obj, cp;
+{
+    char *i_cp;
+    integer o_idx;
+    VALUE idx;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+
+
+    sgpqid_(i_cp, &o_idx, (ftnlen)strlen(i_cp));
+
+    idx = INT2NUM(o_idx);
+
+
+    return idx;
+
+}
+
+static VALUE
+dcl_sgpqcp(obj, idx)
+    VALUE obj, idx;
+{
+    integer i_idx;
+    char *o_cp;
+    VALUE cp;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+
+    o_cp= ALLOCA_N(char, (DFLT_SIZE+1));
+    memset(o_cp, '\0', DFLT_SIZE+1);
+
+    sgpqcp_(&i_idx, o_cp, (ftnlen)DFLT_SIZE);
+
+    cp = rb_str_new2(o_cp);
+
+
+    return cp;
+
+}
+
+static VALUE
+dcl_sgpqcl(obj, idx)
+    VALUE obj, idx;
+{
+    integer i_idx;
+    char *o_cp;
+    VALUE cp;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+
+    o_cp= ALLOCA_N(char, (DFLT_SIZE+1));
+    memset(o_cp, '\0', DFLT_SIZE+1);
+
+    sgpqcl_(&i_idx, o_cp, (ftnlen)DFLT_SIZE);
+
+    cp = rb_str_new2(o_cp);
+
+
+    return cp;
+
+}
+
+static VALUE
+dcl_sgpqit(obj, idx)
+    VALUE obj, idx;
+{
+    integer i_idx;
+    integer o_itp;
+    VALUE itp;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+
+
+    sgpqit_(&i_idx, &o_itp);
+
+    itp = INT2NUM(o_itp);
+
+
+    return itp;
+
+}
+
+static VALUE
+dcl_sgpqvl(obj, idx)
+    VALUE obj, idx;
+{
+    integer i_idx;
+    integer o_ipara;
+    VALUE ipara;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+
+
+    sgpqvl_(&i_idx, &o_ipara);
+
+    ipara = INT2NUM(o_ipara);
+
+
+    return ipara;
+
+}
+
+static VALUE
+dcl_sgpsvl(obj, idx, ipara)
+    VALUE obj, idx, ipara;
+{
+    integer i_idx;
+    integer i_ipara;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(ipara) != T_BIGNUM) || (TYPE(ipara) != T_FIXNUM)) {
+      ipara = rb_funcall(ipara, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+    i_ipara = NUM2INT(ipara);
+
+
+    sgpsvl_(&i_idx, &i_ipara);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgpqin(obj, cp)
+    VALUE obj, cp;
+{
+    char *i_cp;
+    integer o_in;
+    VALUE in;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+
+
+    sgpqin_(i_cp, &o_in, (ftnlen)strlen(i_cp));
+
+    in = INT2NUM(o_in);
+
+
+    return in;
+
+}
+
+static VALUE
+dcl_sgpwsn(obj)
+    VALUE obj;
+{
+    sgpwsn_();
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgsvpt(obj, vxmin, vxmax, vymin, vymax)
+    VALUE obj, vxmin, vxmax, vymin, vymax;
+{
+    real i_vxmin;
+    real i_vxmax;
+    real i_vymin;
+    real i_vymax;
+
+    if (TYPE(vxmin) != T_FLOAT) {
+      vxmin = rb_funcall(vxmin, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vxmax) != T_FLOAT) {
+      vxmax = rb_funcall(vxmax, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vymin) != T_FLOAT) {
+      vymin = rb_funcall(vymin, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vymax) != T_FLOAT) {
+      vymax = rb_funcall(vymax, rb_intern("to_f"), 0);
+    }
+
+    i_vxmin = (real)NUM2DBL(vxmin);
+    i_vxmax = (real)NUM2DBL(vxmax);
+    i_vymin = (real)NUM2DBL(vymin);
+    i_vymax = (real)NUM2DBL(vymax);
+
+
+    sgsvpt_(&i_vxmin, &i_vxmax, &i_vymin, &i_vymax);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqvpt(obj)
+    VALUE obj;
+{
+    real o_vxmin;
+    real o_vxmax;
+    real o_vymin;
+    real o_vymax;
+    VALUE vxmin;
+    VALUE vxmax;
+    VALUE vymin;
+    VALUE vymax;
+
+    sgqvpt_(&o_vxmin, &o_vxmax, &o_vymin, &o_vymax);
+
+    vxmin = rb_float_new((double)o_vxmin);
+    vxmax = rb_float_new((double)o_vxmax);
+    vymin = rb_float_new((double)o_vymin);
+    vymax = rb_float_new((double)o_vymax);
+
+
+    return rb_ary_new3(4, vxmin, vxmax, vymin, vymax);
+
+}
+
+static VALUE
+dcl_sgswnd(obj, uxmin, uxmax, uymin, uymax)
+    VALUE obj, uxmin, uxmax, uymin, uymax;
+{
+    real i_uxmin;
+    real i_uxmax;
+    real i_uymin;
+    real i_uymax;
+
+    if (TYPE(uxmin) != T_FLOAT) {
+      uxmin = rb_funcall(uxmin, rb_intern("to_f"), 0);
+    }
+    if (TYPE(uxmax) != T_FLOAT) {
+      uxmax = rb_funcall(uxmax, rb_intern("to_f"), 0);
+    }
+    if (TYPE(uymin) != T_FLOAT) {
+      uymin = rb_funcall(uymin, rb_intern("to_f"), 0);
+    }
+    if (TYPE(uymax) != T_FLOAT) {
+      uymax = rb_funcall(uymax, rb_intern("to_f"), 0);
+    }
+
+    i_uxmin = (real)NUM2DBL(uxmin);
+    i_uxmax = (real)NUM2DBL(uxmax);
+    i_uymin = (real)NUM2DBL(uymin);
+    i_uymax = (real)NUM2DBL(uymax);
+
+
+    sgswnd_(&i_uxmin, &i_uxmax, &i_uymin, &i_uymax);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqwnd(obj)
+    VALUE obj;
+{
+    real o_uxmin;
+    real o_uxmax;
+    real o_uymin;
+    real o_uymax;
+    VALUE uxmin;
+    VALUE uxmax;
+    VALUE uymin;
+    VALUE uymax;
+
+    sgqwnd_(&o_uxmin, &o_uxmax, &o_uymin, &o_uymax);
+
+    uxmin = rb_float_new((double)o_uxmin);
+    uxmax = rb_float_new((double)o_uxmax);
+    uymin = rb_float_new((double)o_uymin);
+    uymax = rb_float_new((double)o_uymax);
+
+
+    return rb_ary_new3(4, uxmin, uxmax, uymin, uymax);
+
+}
+
+static VALUE
+dcl_sgssim(obj, simfac, vxoff, vyoff)
+    VALUE obj, simfac, vxoff, vyoff;
+{
+    real i_simfac;
+    real i_vxoff;
+    real i_vyoff;
+
+    if (TYPE(simfac) != T_FLOAT) {
+      simfac = rb_funcall(simfac, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vxoff) != T_FLOAT) {
+      vxoff = rb_funcall(vxoff, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vyoff) != T_FLOAT) {
+      vyoff = rb_funcall(vyoff, rb_intern("to_f"), 0);
+    }
+
+    i_simfac = (real)NUM2DBL(simfac);
+    i_vxoff = (real)NUM2DBL(vxoff);
+    i_vyoff = (real)NUM2DBL(vyoff);
+
+
+    sgssim_(&i_simfac, &i_vxoff, &i_vyoff);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqsim(obj)
+    VALUE obj;
+{
+    real o_simfac;
+    real o_vxoff;
+    real o_vyoff;
+    VALUE simfac;
+    VALUE vxoff;
+    VALUE vyoff;
+
+    sgqsim_(&o_simfac, &o_vxoff, &o_vyoff);
+
+    simfac = rb_float_new((double)o_simfac);
+    vxoff = rb_float_new((double)o_vxoff);
+    vyoff = rb_float_new((double)o_vyoff);
+
+
+    return rb_ary_new3(3, simfac, vxoff, vyoff);
+
+}
+
+static VALUE
+dcl_sgsmpl(obj, plx, ply, plrot)
+    VALUE obj, plx, ply, plrot;
+{
+    real i_plx;
+    real i_ply;
+    real i_plrot;
+
+    if (TYPE(plx) != T_FLOAT) {
+      plx = rb_funcall(plx, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ply) != T_FLOAT) {
+      ply = rb_funcall(ply, rb_intern("to_f"), 0);
+    }
+    if (TYPE(plrot) != T_FLOAT) {
+      plrot = rb_funcall(plrot, rb_intern("to_f"), 0);
+    }
+
+    i_plx = (real)NUM2DBL(plx);
+    i_ply = (real)NUM2DBL(ply);
+    i_plrot = (real)NUM2DBL(plrot);
+
+
+    sgsmpl_(&i_plx, &i_ply, &i_plrot);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqmpl(obj)
+    VALUE obj;
+{
+    real o_plx;
+    real o_ply;
+    real o_plrot;
+    VALUE plx;
+    VALUE ply;
+    VALUE plrot;
+
+    sgqmpl_(&o_plx, &o_ply, &o_plrot);
+
+    plx = rb_float_new((double)o_plx);
+    ply = rb_float_new((double)o_ply);
+    plrot = rb_float_new((double)o_plrot);
+
+
+    return rb_ary_new3(3, plx, ply, plrot);
+
+}
+
+static VALUE
+dcl_sgstxy(obj, txmin, txmax, tymin, tymax)
+    VALUE obj, txmin, txmax, tymin, tymax;
+{
+    real i_txmin;
+    real i_txmax;
+    real i_tymin;
+    real i_tymax;
+
+    if (TYPE(txmin) != T_FLOAT) {
+      txmin = rb_funcall(txmin, rb_intern("to_f"), 0);
+    }
+    if (TYPE(txmax) != T_FLOAT) {
+      txmax = rb_funcall(txmax, rb_intern("to_f"), 0);
+    }
+    if (TYPE(tymin) != T_FLOAT) {
+      tymin = rb_funcall(tymin, rb_intern("to_f"), 0);
+    }
+    if (TYPE(tymax) != T_FLOAT) {
+      tymax = rb_funcall(tymax, rb_intern("to_f"), 0);
+    }
+
+    i_txmin = (real)NUM2DBL(txmin);
+    i_txmax = (real)NUM2DBL(txmax);
+    i_tymin = (real)NUM2DBL(tymin);
+    i_tymax = (real)NUM2DBL(tymax);
+
+
+    sgstxy_(&i_txmin, &i_txmax, &i_tymin, &i_tymax);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqtxy(obj)
+    VALUE obj;
+{
+    real o_txmin;
+    real o_txmax;
+    real o_tymin;
+    real o_tymax;
+    VALUE txmin;
+    VALUE txmax;
+    VALUE tymin;
+    VALUE tymax;
+
+    sgqtxy_(&o_txmin, &o_txmax, &o_tymin, &o_tymax);
+
+    txmin = rb_float_new((double)o_txmin);
+    txmax = rb_float_new((double)o_txmax);
+    tymin = rb_float_new((double)o_tymin);
+    tymax = rb_float_new((double)o_tymax);
+
+
+    return rb_ary_new3(4, txmin, txmax, tymin, tymax);
+
+}
+
+static VALUE
+dcl_sgstrn(obj, itr)
+    VALUE obj, itr;
+{
+    integer i_itr;
+
+    if ((TYPE(itr) != T_BIGNUM) || (TYPE(itr) != T_FIXNUM)) {
+      itr = rb_funcall(itr, rb_intern("to_i"), 0);
+    }
+
+    i_itr = NUM2INT(itr);
+
+
+    sgstrn_(&i_itr);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqtrn(obj)
+    VALUE obj;
+{
+    integer o_itr;
+    VALUE itr;
+
+    sgqtrn_(&o_itr);
+
+    itr = INT2NUM(o_itr);
+
+
+    return itr;
+
+}
+
+static VALUE
+dcl_sgstrf(obj)
+    VALUE obj;
+{
+    sgstrf_();
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgtrqf(obj, ntx)
+    VALUE obj, ntx;
+{
+    integer i_ntx;
+    logical o_ltr;
+    VALUE ltr;
+
+    if ((TYPE(ntx) != T_BIGNUM) || (TYPE(ntx) != T_FIXNUM)) {
+      ntx = rb_funcall(ntx, rb_intern("to_i"), 0);
+    }
+
+    i_ntx = NUM2INT(ntx);
+
+
+    sgtrqf_(&i_ntx, &o_ltr);
+
+    ltr = (o_ltr == FALSE_) ? Qfalse : Qtrue;
+
+
+    return ltr;
+
+}
+
+static VALUE
+dcl_sgtrsl(obj, cts)
+    VALUE obj, cts;
+{
+    char *i_cts;
+    char *o_ctl;
+    VALUE ctl;
+
+    if (TYPE(cts) != T_STRING) {
+      cts = rb_funcall(cts, rb_intern("to_str"), 0);
+    }
+
+    i_cts = StringValuePtr(cts);
+
+    o_ctl= ALLOCA_N(char, (DFLT_SIZE+1));
+    memset(o_ctl, '\0', DFLT_SIZE+1);
+
+    sgtrsl_(i_cts, o_ctl, (ftnlen)strlen(i_cts), (ftnlen)DFLT_SIZE);
+
+    ctl = rb_str_new2(o_ctl);
+
+
+    return ctl;
+
+}
+
+static VALUE
+dcl_sgtrsn(obj, cts)
+    VALUE obj, cts;
+{
+    char *i_cts;
+    integer o_ntx;
+    VALUE ntx;
+
+    if (TYPE(cts) != T_STRING) {
+      cts = rb_funcall(cts, rb_intern("to_str"), 0);
+    }
+
+    i_cts = StringValuePtr(cts);
+
+
+    sgtrsn_(i_cts, &o_ntx, (ftnlen)strlen(i_cts));
+
+    ntx = INT2NUM(o_ntx);
+
+
+    return ntx;
+
+}
+
+static VALUE
+dcl_sgtrls(obj, ctl)
+    VALUE obj, ctl;
+{
+    char *i_ctl;
+    char *o_cts;
+    VALUE cts;
+
+    if (TYPE(ctl) != T_STRING) {
+      ctl = rb_funcall(ctl, rb_intern("to_str"), 0);
+    }
+
+    i_ctl = StringValuePtr(ctl);
+
+    o_cts= ALLOCA_N(char, (DFLT_SIZE+1));
+    memset(o_cts, '\0', DFLT_SIZE+1);
+
+    sgtrls_(i_ctl, o_cts, (ftnlen)strlen(i_ctl), (ftnlen)DFLT_SIZE);
+
+    cts = rb_str_new2(o_cts);
+
+
+    return cts;
+
+}
+
+static VALUE
+dcl_sgtrln(obj, ctl)
+    VALUE obj, ctl;
+{
+    char *i_ctl;
+    integer o_ntx;
+    VALUE ntx;
+
+    if (TYPE(ctl) != T_STRING) {
+      ctl = rb_funcall(ctl, rb_intern("to_str"), 0);
+    }
+
+    i_ctl = StringValuePtr(ctl);
+
+
+    sgtrln_(i_ctl, &o_ntx, (ftnlen)strlen(i_ctl));
+
+    ntx = INT2NUM(o_ntx);
+
+
+    return ntx;
+
+}
+
+static VALUE
+dcl_sgtrns(obj, ntx)
+    VALUE obj, ntx;
+{
+    integer i_ntx;
+    char *o_cts;
+    VALUE cts;
+
+    if ((TYPE(ntx) != T_BIGNUM) || (TYPE(ntx) != T_FIXNUM)) {
+      ntx = rb_funcall(ntx, rb_intern("to_i"), 0);
+    }
+
+    i_ntx = NUM2INT(ntx);
+
+    o_cts= ALLOCA_N(char, (DFLT_SIZE+1));
+    memset(o_cts, '\0', DFLT_SIZE+1);
+
+    sgtrns_(&i_ntx, o_cts, (ftnlen)DFLT_SIZE);
+
+    cts = rb_str_new2(o_cts);
+
+
+    return cts;
+
+}
+
+static VALUE
+dcl_sgtrnl(obj, ntx)
+    VALUE obj, ntx;
+{
+    integer i_ntx;
+    char *o_ctl;
+    VALUE ctl;
+
+    if ((TYPE(ntx) != T_BIGNUM) || (TYPE(ntx) != T_FIXNUM)) {
+      ntx = rb_funcall(ntx, rb_intern("to_i"), 0);
+    }
+
+    i_ntx = NUM2INT(ntx);
+
+    o_ctl= ALLOCA_N(char, (DFLT_SIZE+1));
+    memset(o_ctl, '\0', DFLT_SIZE+1);
+
+    sgtrnl_(&i_ntx, o_ctl, (ftnlen)DFLT_SIZE);
+
+    ctl = rb_str_new2(o_ctl);
+
+
+    return ctl;
+
+}
+
+static VALUE
+dcl_isgtrc(obj, ctr)
+    VALUE obj, ctr;
+{
+    char *i_ctr;
+    integer o_rtn_val;
+    VALUE rtn_val;
+
+    if (TYPE(ctr) != T_STRING) {
+      ctr = rb_funcall(ctr, rb_intern("to_str"), 0);
+    }
+
+    i_ctr = StringValuePtr(ctr);
+
+
+    o_rtn_val = isgtrc_(i_ctr, (ftnlen)strlen(i_ctr));
+
+    rtn_val = INT2NUM(o_rtn_val);
+
+
+    return rtn_val;
+
+}
+
+static VALUE
+dcl_sgplu(obj, n, upx, upy)
+    VALUE obj, n, upx, upy;
+{
+    integer i_n;
+    real *i_upx;
+    real *i_upy;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(upx) == T_FLOAT) {
+      upx = rb_Array(upx);
+    }
+    /* if ((TYPE(upx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(upx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(upy) == T_FLOAT) {
+      upy = rb_Array(upy);
+    }
+    /* if ((TYPE(upy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(upy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+
+    i_n = NUM2INT(n);
+    i_upx = dcl_obj2crealary(upx);
+    i_upy = dcl_obj2crealary(upy);
+
+
+    sgplu_(&i_n, i_upx, i_upy);
+
+    dcl_freecrealary(i_upx);
+    dcl_freecrealary(i_upy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgplv(obj, n, vpx, vpy)
+    VALUE obj, n, vpx, vpy;
+{
+    integer i_n;
+    real *i_vpx;
+    real *i_vpy;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(vpx) == T_FLOAT) {
+      vpx = rb_Array(vpx);
+    }
+    /* if ((TYPE(vpx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(vpx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(vpy) == T_FLOAT) {
+      vpy = rb_Array(vpy);
+    }
+    /* if ((TYPE(vpy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(vpy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+
+    i_n = NUM2INT(n);
+    i_vpx = dcl_obj2crealary(vpx);
+    i_vpy = dcl_obj2crealary(vpy);
+
+
+    sgplv_(&i_n, i_vpx, i_vpy);
+
+    dcl_freecrealary(i_vpx);
+    dcl_freecrealary(i_vpy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgplr(obj, n, rpx, rpy)
+    VALUE obj, n, rpx, rpy;
+{
+    integer i_n;
+    real *i_rpx;
+    real *i_rpy;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(rpx) == T_FLOAT) {
+      rpx = rb_Array(rpx);
+    }
+    /* if ((TYPE(rpx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rpx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(rpy) == T_FLOAT) {
+      rpy = rb_Array(rpy);
+    }
+    /* if ((TYPE(rpy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rpy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+
+    i_n = NUM2INT(n);
+    i_rpx = dcl_obj2crealary(rpx);
+    i_rpy = dcl_obj2crealary(rpy);
+
+
+    sgplr_(&i_n, i_rpx, i_rpy);
+
+    dcl_freecrealary(i_rpx);
+    dcl_freecrealary(i_rpy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgsplt(obj, itype)
+    VALUE obj, itype;
+{
+    integer i_itype;
+
+    if ((TYPE(itype) != T_BIGNUM) || (TYPE(itype) != T_FIXNUM)) {
+      itype = rb_funcall(itype, rb_intern("to_i"), 0);
+    }
+
+    i_itype = NUM2INT(itype);
+
+
+    sgsplt_(&i_itype);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqplt(obj)
+    VALUE obj;
+{
+    integer o_itype;
+    VALUE itype;
+
+    sgqplt_(&o_itype);
+
+    itype = INT2NUM(o_itype);
+
+
+    return itype;
+
+}
+
+static VALUE
+dcl_sgspli(obj, index)
+    VALUE obj, index;
+{
+    integer i_index;
+
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_index = NUM2INT(index);
+
+
+    sgspli_(&i_index);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqpli(obj)
+    VALUE obj;
+{
+    integer o_index;
+    VALUE index;
+
+    sgqpli_(&o_index);
+
+    index = INT2NUM(o_index);
+
+
+    return index;
+
+}
+
+static VALUE
+dcl_sgplzu(obj, n, upx, upy, itype, index)
+    VALUE obj, n, upx, upy, itype, index;
+{
+    integer i_n;
+    real *i_upx;
+    real *i_upy;
+    integer i_itype;
+    integer i_index;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(upx) == T_FLOAT) {
+      upx = rb_Array(upx);
+    }
+    /* if ((TYPE(upx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(upx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(upy) == T_FLOAT) {
+      upy = rb_Array(upy);
+    }
+    /* if ((TYPE(upy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(upy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(itype) != T_BIGNUM) || (TYPE(itype) != T_FIXNUM)) {
+      itype = rb_funcall(itype, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_itype = NUM2INT(itype);
+    i_index = NUM2INT(index);
+    i_upx = dcl_obj2crealary(upx);
+    i_upy = dcl_obj2crealary(upy);
+
+
+    sgplzu_(&i_n, i_upx, i_upy, &i_itype, &i_index);
+
+    dcl_freecrealary(i_upx);
+    dcl_freecrealary(i_upy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgplzv(obj, n, vpx, vpy, itype, index)
+    VALUE obj, n, vpx, vpy, itype, index;
+{
+    integer i_n;
+    real *i_vpx;
+    real *i_vpy;
+    integer i_itype;
+    integer i_index;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(vpx) == T_FLOAT) {
+      vpx = rb_Array(vpx);
+    }
+    /* if ((TYPE(vpx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(vpx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(vpy) == T_FLOAT) {
+      vpy = rb_Array(vpy);
+    }
+    /* if ((TYPE(vpy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(vpy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(itype) != T_BIGNUM) || (TYPE(itype) != T_FIXNUM)) {
+      itype = rb_funcall(itype, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_itype = NUM2INT(itype);
+    i_index = NUM2INT(index);
+    i_vpx = dcl_obj2crealary(vpx);
+    i_vpy = dcl_obj2crealary(vpy);
+
+
+    sgplzv_(&i_n, i_vpx, i_vpy, &i_itype, &i_index);
+
+    dcl_freecrealary(i_vpx);
+    dcl_freecrealary(i_vpy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgplzr(obj, n, rpx, rpy, itype, index)
+    VALUE obj, n, rpx, rpy, itype, index;
+{
+    integer i_n;
+    real *i_rpx;
+    real *i_rpy;
+    integer i_itype;
+    integer i_index;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(rpx) == T_FLOAT) {
+      rpx = rb_Array(rpx);
+    }
+    /* if ((TYPE(rpx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rpx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(rpy) == T_FLOAT) {
+      rpy = rb_Array(rpy);
+    }
+    /* if ((TYPE(rpy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rpy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(itype) != T_BIGNUM) || (TYPE(itype) != T_FIXNUM)) {
+      itype = rb_funcall(itype, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_itype = NUM2INT(itype);
+    i_index = NUM2INT(index);
+    i_rpx = dcl_obj2crealary(rpx);
+    i_rpy = dcl_obj2crealary(rpy);
+
+
+    sgplzr_(&i_n, i_rpx, i_rpy, &i_itype, &i_index);
+
+    dcl_freecrealary(i_rpx);
+    dcl_freecrealary(i_rpy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgpmu(obj, n, upx, upy)
+    VALUE obj, n, upx, upy;
+{
+    integer i_n;
+    real *i_upx;
+    real *i_upy;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(upx) == T_FLOAT) {
+      upx = rb_Array(upx);
+    }
+    /* if ((TYPE(upx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(upx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(upy) == T_FLOAT) {
+      upy = rb_Array(upy);
+    }
+    /* if ((TYPE(upy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(upy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+
+    i_n = NUM2INT(n);
+    i_upx = dcl_obj2crealary(upx);
+    i_upy = dcl_obj2crealary(upy);
+
+
+    sgpmu_(&i_n, i_upx, i_upy);
+
+    dcl_freecrealary(i_upx);
+    dcl_freecrealary(i_upy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgpmv(obj, n, vpx, vpy)
+    VALUE obj, n, vpx, vpy;
+{
+    integer i_n;
+    real *i_vpx;
+    real *i_vpy;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(vpx) == T_FLOAT) {
+      vpx = rb_Array(vpx);
+    }
+    /* if ((TYPE(vpx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(vpx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(vpy) == T_FLOAT) {
+      vpy = rb_Array(vpy);
+    }
+    /* if ((TYPE(vpy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(vpy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+
+    i_n = NUM2INT(n);
+    i_vpx = dcl_obj2crealary(vpx);
+    i_vpy = dcl_obj2crealary(vpy);
+
+
+    sgpmv_(&i_n, i_vpx, i_vpy);
+
+    dcl_freecrealary(i_vpx);
+    dcl_freecrealary(i_vpy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgpmr(obj, n, rpx, rpy)
+    VALUE obj, n, rpx, rpy;
+{
+    integer i_n;
+    real *i_rpx;
+    real *i_rpy;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(rpx) == T_FLOAT) {
+      rpx = rb_Array(rpx);
+    }
+    /* if ((TYPE(rpx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rpx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(rpy) == T_FLOAT) {
+      rpy = rb_Array(rpy);
+    }
+    /* if ((TYPE(rpy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rpy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+
+    i_n = NUM2INT(n);
+    i_rpx = dcl_obj2crealary(rpx);
+    i_rpy = dcl_obj2crealary(rpy);
+
+
+    sgpmr_(&i_n, i_rpx, i_rpy);
+
+    dcl_freecrealary(i_rpx);
+    dcl_freecrealary(i_rpy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgspmt(obj, itype)
+    VALUE obj, itype;
+{
+    integer i_itype;
+
+    if ((TYPE(itype) != T_BIGNUM) || (TYPE(itype) != T_FIXNUM)) {
+      itype = rb_funcall(itype, rb_intern("to_i"), 0);
+    }
+
+    i_itype = NUM2INT(itype);
+
+
+    sgspmt_(&i_itype);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqpmt(obj)
+    VALUE obj;
+{
+    integer o_itype;
+    VALUE itype;
+
+    sgqpmt_(&o_itype);
+
+    itype = INT2NUM(o_itype);
+
+
+    return itype;
+
+}
+
+static VALUE
+dcl_sgspmi(obj, index)
+    VALUE obj, index;
+{
+    integer i_index;
+
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_index = NUM2INT(index);
+
+
+    sgspmi_(&i_index);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqpmi(obj)
+    VALUE obj;
+{
+    integer o_index;
+    VALUE index;
+
+    sgqpmi_(&o_index);
+
+    index = INT2NUM(o_index);
+
+
+    return index;
+
+}
+
+static VALUE
+dcl_sgspms(obj, rsize)
+    VALUE obj, rsize;
+{
+    real i_rsize;
+
+    if (TYPE(rsize) != T_FLOAT) {
+      rsize = rb_funcall(rsize, rb_intern("to_f"), 0);
+    }
+
+    i_rsize = (real)NUM2DBL(rsize);
+
+
+    sgspms_(&i_rsize);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqpms(obj)
+    VALUE obj;
+{
+    real o_rsize;
+    VALUE rsize;
+
+    sgqpms_(&o_rsize);
+
+    rsize = rb_float_new((double)o_rsize);
+
+
+    return rsize;
+
+}
+
+static VALUE
+dcl_sgtxu(obj, ux, uy, chars)
+    VALUE obj, ux, uy, chars;
+{
+    real i_ux;
+    real i_uy;
+    char *i_chars;
+
+    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);
+    }
+    if (TYPE(chars) != T_STRING) {
+      chars = rb_funcall(chars, rb_intern("to_str"), 0);
+    }
+
+    i_ux = (real)NUM2DBL(ux);
+    i_uy = (real)NUM2DBL(uy);
+    i_chars = StringValuePtr(chars);
+
+
+    sgtxu_(&i_ux, &i_uy, i_chars, (ftnlen)strlen(i_chars));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgtxv(obj, vx, vy, chars)
+    VALUE obj, vx, vy, chars;
+{
+    real i_vx;
+    real i_vy;
+    char *i_chars;
+
+    if (TYPE(vx) != T_FLOAT) {
+      vx = rb_funcall(vx, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vy) != T_FLOAT) {
+      vy = rb_funcall(vy, rb_intern("to_f"), 0);
+    }
+    if (TYPE(chars) != T_STRING) {
+      chars = rb_funcall(chars, rb_intern("to_str"), 0);
+    }
+
+    i_vx = (real)NUM2DBL(vx);
+    i_vy = (real)NUM2DBL(vy);
+    i_chars = StringValuePtr(chars);
+
+
+    sgtxv_(&i_vx, &i_vy, i_chars, (ftnlen)strlen(i_chars));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgtxr(obj, rx, ry, chars)
+    VALUE obj, rx, ry, chars;
+{
+    real i_rx;
+    real i_ry;
+    char *i_chars;
+
+    if (TYPE(rx) != T_FLOAT) {
+      rx = rb_funcall(rx, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ry) != T_FLOAT) {
+      ry = rb_funcall(ry, rb_intern("to_f"), 0);
+    }
+    if (TYPE(chars) != T_STRING) {
+      chars = rb_funcall(chars, rb_intern("to_str"), 0);
+    }
+
+    i_rx = (real)NUM2DBL(rx);
+    i_ry = (real)NUM2DBL(ry);
+    i_chars = StringValuePtr(chars);
+
+
+    sgtxr_(&i_rx, &i_ry, i_chars, (ftnlen)strlen(i_chars));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgstxs(obj, rsize)
+    VALUE obj, rsize;
+{
+    real i_rsize;
+
+    if (TYPE(rsize) != T_FLOAT) {
+      rsize = rb_funcall(rsize, rb_intern("to_f"), 0);
+    }
+
+    i_rsize = (real)NUM2DBL(rsize);
+
+
+    sgstxs_(&i_rsize);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqtxs(obj)
+    VALUE obj;
+{
+    real o_rsize;
+    VALUE rsize;
+
+    sgqtxs_(&o_rsize);
+
+    rsize = rb_float_new((double)o_rsize);
+
+
+    return rsize;
+
+}
+
+static VALUE
+dcl_sgstxr(obj, irota)
+    VALUE obj, irota;
+{
+    integer i_irota;
+
+    if ((TYPE(irota) != T_BIGNUM) || (TYPE(irota) != T_FIXNUM)) {
+      irota = rb_funcall(irota, rb_intern("to_i"), 0);
+    }
+
+    i_irota = NUM2INT(irota);
+
+
+    sgstxr_(&i_irota);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqtxr(obj)
+    VALUE obj;
+{
+    integer o_irota;
+    VALUE irota;
+
+    sgqtxr_(&o_irota);
+
+    irota = INT2NUM(o_irota);
+
+
+    return irota;
+
+}
+
+static VALUE
+dcl_sgstxc(obj, icent)
+    VALUE obj, icent;
+{
+    integer i_icent;
+
+    if ((TYPE(icent) != T_BIGNUM) || (TYPE(icent) != T_FIXNUM)) {
+      icent = rb_funcall(icent, rb_intern("to_i"), 0);
+    }
+
+    i_icent = NUM2INT(icent);
+
+
+    sgstxc_(&i_icent);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqtxc(obj)
+    VALUE obj;
+{
+    integer o_icent;
+    VALUE icent;
+
+    sgqtxc_(&o_icent);
+
+    icent = INT2NUM(o_icent);
+
+
+    return icent;
+
+}
+
+static VALUE
+dcl_sgstxi(obj, index)
+    VALUE obj, index;
+{
+    integer i_index;
+
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_index = NUM2INT(index);
+
+
+    sgstxi_(&i_index);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqtxi(obj)
+    VALUE obj;
+{
+    integer o_index;
+    VALUE index;
+
+    sgqtxi_(&o_index);
+
+    index = INT2NUM(o_index);
+
+
+    return index;
+
+}
+
+static VALUE
+dcl_sgpmzu(obj, n, upx, upy, itype, index, rsize)
+    VALUE obj, n, upx, upy, itype, index, rsize;
+{
+    integer i_n;
+    real *i_upx;
+    real *i_upy;
+    integer i_itype;
+    integer i_index;
+    real i_rsize;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(upx) == T_FLOAT) {
+      upx = rb_Array(upx);
+    }
+    /* if ((TYPE(upx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(upx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(upy) == T_FLOAT) {
+      upy = rb_Array(upy);
+    }
+    /* if ((TYPE(upy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(upy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(itype) != T_BIGNUM) || (TYPE(itype) != T_FIXNUM)) {
+      itype = rb_funcall(itype, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+    if (TYPE(rsize) != T_FLOAT) {
+      rsize = rb_funcall(rsize, rb_intern("to_f"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_itype = NUM2INT(itype);
+    i_index = NUM2INT(index);
+    i_rsize = (real)NUM2DBL(rsize);
+    i_upx = dcl_obj2crealary(upx);
+    i_upy = dcl_obj2crealary(upy);
+
+
+    sgpmzu_(&i_n, i_upx, i_upy, &i_itype, &i_index, &i_rsize);
+
+    dcl_freecrealary(i_upx);
+    dcl_freecrealary(i_upy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgpmzv(obj, n, vpx, vpy, itype, index, rsize)
+    VALUE obj, n, vpx, vpy, itype, index, rsize;
+{
+    integer i_n;
+    real *i_vpx;
+    real *i_vpy;
+    integer i_itype;
+    integer i_index;
+    real i_rsize;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(vpx) == T_FLOAT) {
+      vpx = rb_Array(vpx);
+    }
+    /* if ((TYPE(vpx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(vpx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(vpy) == T_FLOAT) {
+      vpy = rb_Array(vpy);
+    }
+    /* if ((TYPE(vpy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(vpy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(itype) != T_BIGNUM) || (TYPE(itype) != T_FIXNUM)) {
+      itype = rb_funcall(itype, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+    if (TYPE(rsize) != T_FLOAT) {
+      rsize = rb_funcall(rsize, rb_intern("to_f"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_itype = NUM2INT(itype);
+    i_index = NUM2INT(index);
+    i_rsize = (real)NUM2DBL(rsize);
+    i_vpx = dcl_obj2crealary(vpx);
+    i_vpy = dcl_obj2crealary(vpy);
+
+
+    sgpmzv_(&i_n, i_vpx, i_vpy, &i_itype, &i_index, &i_rsize);
+
+    dcl_freecrealary(i_vpx);
+    dcl_freecrealary(i_vpy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgpmzr(obj, n, rpx, rpy, itype, index, rsize)
+    VALUE obj, n, rpx, rpy, itype, index, rsize;
+{
+    integer i_n;
+    real *i_rpx;
+    real *i_rpy;
+    integer i_itype;
+    integer i_index;
+    real i_rsize;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(rpx) == T_FLOAT) {
+      rpx = rb_Array(rpx);
+    }
+    /* if ((TYPE(rpx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rpx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(rpy) == T_FLOAT) {
+      rpy = rb_Array(rpy);
+    }
+    /* if ((TYPE(rpy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rpy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(itype) != T_BIGNUM) || (TYPE(itype) != T_FIXNUM)) {
+      itype = rb_funcall(itype, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+    if (TYPE(rsize) != T_FLOAT) {
+      rsize = rb_funcall(rsize, rb_intern("to_f"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_itype = NUM2INT(itype);
+    i_index = NUM2INT(index);
+    i_rsize = (real)NUM2DBL(rsize);
+    i_rpx = dcl_obj2crealary(rpx);
+    i_rpy = dcl_obj2crealary(rpy);
+
+
+    sgpmzr_(&i_n, i_rpx, i_rpy, &i_itype, &i_index, &i_rsize);
+
+    dcl_freecrealary(i_rpx);
+    dcl_freecrealary(i_rpy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgtxzu(obj, ux, uy, chars, rsize, irota, icent, index)
+    VALUE obj, ux, uy, chars, rsize, irota, icent, index;
+{
+    real i_ux;
+    real i_uy;
+    char *i_chars;
+    real i_rsize;
+    integer i_irota;
+    integer i_icent;
+    integer i_index;
+
+    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);
+    }
+    if (TYPE(chars) != T_STRING) {
+      chars = rb_funcall(chars, rb_intern("to_str"), 0);
+    }
+    if (TYPE(rsize) != T_FLOAT) {
+      rsize = rb_funcall(rsize, rb_intern("to_f"), 0);
+    }
+    if ((TYPE(irota) != T_BIGNUM) || (TYPE(irota) != T_FIXNUM)) {
+      irota = rb_funcall(irota, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(icent) != T_BIGNUM) || (TYPE(icent) != T_FIXNUM)) {
+      icent = rb_funcall(icent, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_ux = (real)NUM2DBL(ux);
+    i_uy = (real)NUM2DBL(uy);
+    i_chars = StringValuePtr(chars);
+    i_rsize = (real)NUM2DBL(rsize);
+    i_irota = NUM2INT(irota);
+    i_icent = NUM2INT(icent);
+    i_index = NUM2INT(index);
+
+
+    sgtxzu_(&i_ux, &i_uy, i_chars, &i_rsize, &i_irota, &i_icent, &i_index, (ftnlen)strlen(i_chars));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgtxzv(obj, vx, vy, chars, rsize, irota, icent, index)
+    VALUE obj, vx, vy, chars, rsize, irota, icent, index;
+{
+    real i_vx;
+    real i_vy;
+    char *i_chars;
+    real i_rsize;
+    integer i_irota;
+    integer i_icent;
+    integer i_index;
+
+    if (TYPE(vx) != T_FLOAT) {
+      vx = rb_funcall(vx, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vy) != T_FLOAT) {
+      vy = rb_funcall(vy, rb_intern("to_f"), 0);
+    }
+    if (TYPE(chars) != T_STRING) {
+      chars = rb_funcall(chars, rb_intern("to_str"), 0);
+    }
+    if (TYPE(rsize) != T_FLOAT) {
+      rsize = rb_funcall(rsize, rb_intern("to_f"), 0);
+    }
+    if ((TYPE(irota) != T_BIGNUM) || (TYPE(irota) != T_FIXNUM)) {
+      irota = rb_funcall(irota, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(icent) != T_BIGNUM) || (TYPE(icent) != T_FIXNUM)) {
+      icent = rb_funcall(icent, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_vx = (real)NUM2DBL(vx);
+    i_vy = (real)NUM2DBL(vy);
+    i_chars = StringValuePtr(chars);
+    i_rsize = (real)NUM2DBL(rsize);
+    i_irota = NUM2INT(irota);
+    i_icent = NUM2INT(icent);
+    i_index = NUM2INT(index);
+
+
+    sgtxzv_(&i_vx, &i_vy, i_chars, &i_rsize, &i_irota, &i_icent, &i_index, (ftnlen)strlen(i_chars));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgtxzr(obj, rx, ry, chars, rsize, irota, icent, index)
+    VALUE obj, rx, ry, chars, rsize, irota, icent, index;
+{
+    real i_rx;
+    real i_ry;
+    char *i_chars;
+    real i_rsize;
+    integer i_irota;
+    integer i_icent;
+    integer i_index;
+
+    if (TYPE(rx) != T_FLOAT) {
+      rx = rb_funcall(rx, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ry) != T_FLOAT) {
+      ry = rb_funcall(ry, rb_intern("to_f"), 0);
+    }
+    if (TYPE(chars) != T_STRING) {
+      chars = rb_funcall(chars, rb_intern("to_str"), 0);
+    }
+    if (TYPE(rsize) != T_FLOAT) {
+      rsize = rb_funcall(rsize, rb_intern("to_f"), 0);
+    }
+    if ((TYPE(irota) != T_BIGNUM) || (TYPE(irota) != T_FIXNUM)) {
+      irota = rb_funcall(irota, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(icent) != T_BIGNUM) || (TYPE(icent) != T_FIXNUM)) {
+      icent = rb_funcall(icent, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_rx = (real)NUM2DBL(rx);
+    i_ry = (real)NUM2DBL(ry);
+    i_chars = StringValuePtr(chars);
+    i_rsize = (real)NUM2DBL(rsize);
+    i_irota = NUM2INT(irota);
+    i_icent = NUM2INT(icent);
+    i_index = NUM2INT(index);
+
+
+    sgtxzr_(&i_rx, &i_ry, i_chars, &i_rsize, &i_irota, &i_icent, &i_index, (ftnlen)strlen(i_chars));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgtnu(obj, n, upx, upy)
+    VALUE obj, n, upx, upy;
+{
+    integer i_n;
+    real *i_upx;
+    real *i_upy;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(upx) == T_FLOAT) {
+      upx = rb_Array(upx);
+    }
+    /* if ((TYPE(upx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(upx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(upy) == T_FLOAT) {
+      upy = rb_Array(upy);
+    }
+    /* if ((TYPE(upy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(upy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+
+    i_n = NUM2INT(n);
+    i_upx = dcl_obj2crealary(upx);
+    i_upy = dcl_obj2crealary(upy);
+
+
+    sgtnu_(&i_n, i_upx, i_upy);
+
+    dcl_freecrealary(i_upx);
+    dcl_freecrealary(i_upy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgtnv(obj, n, vpx, vpy)
+    VALUE obj, n, vpx, vpy;
+{
+    integer i_n;
+    real *i_vpx;
+    real *i_vpy;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(vpx) == T_FLOAT) {
+      vpx = rb_Array(vpx);
+    }
+    /* if ((TYPE(vpx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(vpx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(vpy) == T_FLOAT) {
+      vpy = rb_Array(vpy);
+    }
+    /* if ((TYPE(vpy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(vpy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+
+    i_n = NUM2INT(n);
+    i_vpx = dcl_obj2crealary(vpx);
+    i_vpy = dcl_obj2crealary(vpy);
+
+
+    sgtnv_(&i_n, i_vpx, i_vpy);
+
+    dcl_freecrealary(i_vpx);
+    dcl_freecrealary(i_vpy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgtnr(obj, n, rpx, rpy)
+    VALUE obj, n, rpx, rpy;
+{
+    integer i_n;
+    real *i_rpx;
+    real *i_rpy;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(rpx) == T_FLOAT) {
+      rpx = rb_Array(rpx);
+    }
+    /* if ((TYPE(rpx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rpx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(rpy) == T_FLOAT) {
+      rpy = rb_Array(rpy);
+    }
+    /* if ((TYPE(rpy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rpy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+
+    i_n = NUM2INT(n);
+    i_rpx = dcl_obj2crealary(rpx);
+    i_rpy = dcl_obj2crealary(rpy);
+
+
+    sgtnr_(&i_n, i_rpx, i_rpy);
+
+    dcl_freecrealary(i_rpx);
+    dcl_freecrealary(i_rpy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgstnp(obj, itpat)
+    VALUE obj, itpat;
+{
+    integer i_itpat;
+
+    if ((TYPE(itpat) != T_BIGNUM) || (TYPE(itpat) != T_FIXNUM)) {
+      itpat = rb_funcall(itpat, rb_intern("to_i"), 0);
+    }
+
+    i_itpat = NUM2INT(itpat);
+
+
+    sgstnp_(&i_itpat);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqtnp(obj)
+    VALUE obj;
+{
+    integer o_itpat;
+    VALUE itpat;
+
+    sgqtnp_(&o_itpat);
+
+    itpat = INT2NUM(o_itpat);
+
+
+    return itpat;
+
+}
+
+static VALUE
+dcl_sgtnzu(obj, n, upx, upy, itpat)
+    VALUE obj, n, upx, upy, itpat;
+{
+    integer i_n;
+    real *i_upx;
+    real *i_upy;
+    integer i_itpat;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(upx) == T_FLOAT) {
+      upx = rb_Array(upx);
+    }
+    /* if ((TYPE(upx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(upx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(upy) == T_FLOAT) {
+      upy = rb_Array(upy);
+    }
+    /* if ((TYPE(upy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(upy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(itpat) != T_BIGNUM) || (TYPE(itpat) != T_FIXNUM)) {
+      itpat = rb_funcall(itpat, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_itpat = NUM2INT(itpat);
+    i_upx = dcl_obj2crealary(upx);
+    i_upy = dcl_obj2crealary(upy);
+
+
+    sgtnzu_(&i_n, i_upx, i_upy, &i_itpat);
+
+    dcl_freecrealary(i_upx);
+    dcl_freecrealary(i_upy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgtnzv(obj, n, vpx, vpy, itpat)
+    VALUE obj, n, vpx, vpy, itpat;
+{
+    integer i_n;
+    real *i_vpx;
+    real *i_vpy;
+    integer i_itpat;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(vpx) == T_FLOAT) {
+      vpx = rb_Array(vpx);
+    }
+    /* if ((TYPE(vpx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(vpx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(vpy) == T_FLOAT) {
+      vpy = rb_Array(vpy);
+    }
+    /* if ((TYPE(vpy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(vpy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(itpat) != T_BIGNUM) || (TYPE(itpat) != T_FIXNUM)) {
+      itpat = rb_funcall(itpat, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_itpat = NUM2INT(itpat);
+    i_vpx = dcl_obj2crealary(vpx);
+    i_vpy = dcl_obj2crealary(vpy);
+
+
+    sgtnzv_(&i_n, i_vpx, i_vpy, &i_itpat);
+
+    dcl_freecrealary(i_vpx);
+    dcl_freecrealary(i_vpy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgtnzr(obj, n, rpx, rpy, itpat)
+    VALUE obj, n, rpx, rpy, itpat;
+{
+    integer i_n;
+    real *i_rpx;
+    real *i_rpy;
+    integer i_itpat;
+
+    if ((TYPE(n) != T_BIGNUM) || (TYPE(n) != T_FIXNUM)) {
+      n = rb_funcall(n, rb_intern("to_i"), 0);
+    }
+    if (TYPE(rpx) == T_FLOAT) {
+      rpx = rb_Array(rpx);
+    }
+    /* if ((TYPE(rpx) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rpx, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if (TYPE(rpy) == T_FLOAT) {
+      rpy = rb_Array(rpy);
+    }
+    /* if ((TYPE(rpy) != T_ARRAY) && 
+           (rb_obj_is_kind_of(rpy, cNArray) != Qtrue)) {
+         rb_raise(rb_eTypeError, "invalid type");
+       }  -- no check since obj2c*ary will do that */
+    if ((TYPE(itpat) != T_BIGNUM) || (TYPE(itpat) != T_FIXNUM)) {
+      itpat = rb_funcall(itpat, rb_intern("to_i"), 0);
+    }
+
+    i_n = NUM2INT(n);
+    i_itpat = NUM2INT(itpat);
+    i_rpx = dcl_obj2crealary(rpx);
+    i_rpy = dcl_obj2crealary(rpy);
+
+
+    sgtnzr_(&i_n, i_rpx, i_rpy, &i_itpat);
+
+    dcl_freecrealary(i_rpx);
+    dcl_freecrealary(i_rpy);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sglnu(obj, ux1, uy1, ux2, uy2)
+    VALUE obj, ux1, uy1, ux2, uy2;
+{
+    real i_ux1;
+    real i_uy1;
+    real i_ux2;
+    real i_uy2;
+
+    if (TYPE(ux1) != T_FLOAT) {
+      ux1 = rb_funcall(ux1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(uy1) != T_FLOAT) {
+      uy1 = rb_funcall(uy1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ux2) != T_FLOAT) {
+      ux2 = rb_funcall(ux2, rb_intern("to_f"), 0);
+    }
+    if (TYPE(uy2) != T_FLOAT) {
+      uy2 = rb_funcall(uy2, rb_intern("to_f"), 0);
+    }
+
+    i_ux1 = (real)NUM2DBL(ux1);
+    i_uy1 = (real)NUM2DBL(uy1);
+    i_ux2 = (real)NUM2DBL(ux2);
+    i_uy2 = (real)NUM2DBL(uy2);
+
+
+    sglnu_(&i_ux1, &i_uy1, &i_ux2, &i_uy2);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sglnv(obj, vx1, vy1, vx2, vy2)
+    VALUE obj, vx1, vy1, vx2, vy2;
+{
+    real i_vx1;
+    real i_vy1;
+    real i_vx2;
+    real i_vy2;
+
+    if (TYPE(vx1) != T_FLOAT) {
+      vx1 = rb_funcall(vx1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vy1) != T_FLOAT) {
+      vy1 = rb_funcall(vy1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vx2) != T_FLOAT) {
+      vx2 = rb_funcall(vx2, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vy2) != T_FLOAT) {
+      vy2 = rb_funcall(vy2, rb_intern("to_f"), 0);
+    }
+
+    i_vx1 = (real)NUM2DBL(vx1);
+    i_vy1 = (real)NUM2DBL(vy1);
+    i_vx2 = (real)NUM2DBL(vx2);
+    i_vy2 = (real)NUM2DBL(vy2);
+
+
+    sglnv_(&i_vx1, &i_vy1, &i_vx2, &i_vy2);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sglnr(obj, rx1, ry1, rx2, ry2)
+    VALUE obj, rx1, ry1, rx2, ry2;
+{
+    real i_rx1;
+    real i_ry1;
+    real i_rx2;
+    real i_ry2;
+
+    if (TYPE(rx1) != T_FLOAT) {
+      rx1 = rb_funcall(rx1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ry1) != T_FLOAT) {
+      ry1 = rb_funcall(ry1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(rx2) != T_FLOAT) {
+      rx2 = rb_funcall(rx2, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ry2) != T_FLOAT) {
+      ry2 = rb_funcall(ry2, rb_intern("to_f"), 0);
+    }
+
+    i_rx1 = (real)NUM2DBL(rx1);
+    i_ry1 = (real)NUM2DBL(ry1);
+    i_rx2 = (real)NUM2DBL(rx2);
+    i_ry2 = (real)NUM2DBL(ry2);
+
+
+    sglnr_(&i_rx1, &i_ry1, &i_rx2, &i_ry2);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgslni(obj, index)
+    VALUE obj, index;
+{
+    integer i_index;
+
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_index = NUM2INT(index);
+
+
+    sgslni_(&i_index);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqlni(obj)
+    VALUE obj;
+{
+    integer o_index;
+    VALUE index;
+
+    sgqlni_(&o_index);
+
+    index = INT2NUM(o_index);
+
+
+    return index;
+
+}
+
+static VALUE
+dcl_sglnzu(obj, ux1, uy1, ux2, uy2, index)
+    VALUE obj, ux1, uy1, ux2, uy2, index;
+{
+    real i_ux1;
+    real i_uy1;
+    real i_ux2;
+    real i_uy2;
+    integer i_index;
+
+    if (TYPE(ux1) != T_FLOAT) {
+      ux1 = rb_funcall(ux1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(uy1) != T_FLOAT) {
+      uy1 = rb_funcall(uy1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ux2) != T_FLOAT) {
+      ux2 = rb_funcall(ux2, rb_intern("to_f"), 0);
+    }
+    if (TYPE(uy2) != T_FLOAT) {
+      uy2 = rb_funcall(uy2, rb_intern("to_f"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_ux1 = (real)NUM2DBL(ux1);
+    i_uy1 = (real)NUM2DBL(uy1);
+    i_ux2 = (real)NUM2DBL(ux2);
+    i_uy2 = (real)NUM2DBL(uy2);
+    i_index = NUM2INT(index);
+
+
+    sglnzu_(&i_ux1, &i_uy1, &i_ux2, &i_uy2, &i_index);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sglnzv(obj, vx1, vy1, vx2, vy2, index)
+    VALUE obj, vx1, vy1, vx2, vy2, index;
+{
+    real i_vx1;
+    real i_vy1;
+    real i_vx2;
+    real i_vy2;
+    integer i_index;
+
+    if (TYPE(vx1) != T_FLOAT) {
+      vx1 = rb_funcall(vx1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vy1) != T_FLOAT) {
+      vy1 = rb_funcall(vy1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vx2) != T_FLOAT) {
+      vx2 = rb_funcall(vx2, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vy2) != T_FLOAT) {
+      vy2 = rb_funcall(vy2, rb_intern("to_f"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_vx1 = (real)NUM2DBL(vx1);
+    i_vy1 = (real)NUM2DBL(vy1);
+    i_vx2 = (real)NUM2DBL(vx2);
+    i_vy2 = (real)NUM2DBL(vy2);
+    i_index = NUM2INT(index);
+
+
+    sglnzv_(&i_vx1, &i_vy1, &i_vx2, &i_vy2, &i_index);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sglnzr(obj, rx1, ry1, rx2, ry2, index)
+    VALUE obj, rx1, ry1, rx2, ry2, index;
+{
+    real i_rx1;
+    real i_ry1;
+    real i_rx2;
+    real i_ry2;
+    integer i_index;
+
+    if (TYPE(rx1) != T_FLOAT) {
+      rx1 = rb_funcall(rx1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ry1) != T_FLOAT) {
+      ry1 = rb_funcall(ry1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(rx2) != T_FLOAT) {
+      rx2 = rb_funcall(rx2, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ry2) != T_FLOAT) {
+      ry2 = rb_funcall(ry2, rb_intern("to_f"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_rx1 = (real)NUM2DBL(rx1);
+    i_ry1 = (real)NUM2DBL(ry1);
+    i_rx2 = (real)NUM2DBL(rx2);
+    i_ry2 = (real)NUM2DBL(ry2);
+    i_index = NUM2INT(index);
+
+
+    sglnzr_(&i_rx1, &i_ry1, &i_rx2, &i_ry2, &i_index);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sglau(obj, ux1, uy1, ux2, uy2)
+    VALUE obj, ux1, uy1, ux2, uy2;
+{
+    real i_ux1;
+    real i_uy1;
+    real i_ux2;
+    real i_uy2;
+
+    if (TYPE(ux1) != T_FLOAT) {
+      ux1 = rb_funcall(ux1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(uy1) != T_FLOAT) {
+      uy1 = rb_funcall(uy1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ux2) != T_FLOAT) {
+      ux2 = rb_funcall(ux2, rb_intern("to_f"), 0);
+    }
+    if (TYPE(uy2) != T_FLOAT) {
+      uy2 = rb_funcall(uy2, rb_intern("to_f"), 0);
+    }
+
+    i_ux1 = (real)NUM2DBL(ux1);
+    i_uy1 = (real)NUM2DBL(uy1);
+    i_ux2 = (real)NUM2DBL(ux2);
+    i_uy2 = (real)NUM2DBL(uy2);
+
+
+    sglau_(&i_ux1, &i_uy1, &i_ux2, &i_uy2);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sglav(obj, vx1, vy1, vx2, vy2)
+    VALUE obj, vx1, vy1, vx2, vy2;
+{
+    real i_vx1;
+    real i_vy1;
+    real i_vx2;
+    real i_vy2;
+
+    if (TYPE(vx1) != T_FLOAT) {
+      vx1 = rb_funcall(vx1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vy1) != T_FLOAT) {
+      vy1 = rb_funcall(vy1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vx2) != T_FLOAT) {
+      vx2 = rb_funcall(vx2, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vy2) != T_FLOAT) {
+      vy2 = rb_funcall(vy2, rb_intern("to_f"), 0);
+    }
+
+    i_vx1 = (real)NUM2DBL(vx1);
+    i_vy1 = (real)NUM2DBL(vy1);
+    i_vx2 = (real)NUM2DBL(vx2);
+    i_vy2 = (real)NUM2DBL(vy2);
+
+
+    sglav_(&i_vx1, &i_vy1, &i_vx2, &i_vy2);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sglar(obj, rx1, ry1, rx2, ry2)
+    VALUE obj, rx1, ry1, rx2, ry2;
+{
+    real i_rx1;
+    real i_ry1;
+    real i_rx2;
+    real i_ry2;
+
+    if (TYPE(rx1) != T_FLOAT) {
+      rx1 = rb_funcall(rx1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ry1) != T_FLOAT) {
+      ry1 = rb_funcall(ry1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(rx2) != T_FLOAT) {
+      rx2 = rb_funcall(rx2, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ry2) != T_FLOAT) {
+      ry2 = rb_funcall(ry2, rb_intern("to_f"), 0);
+    }
+
+    i_rx1 = (real)NUM2DBL(rx1);
+    i_ry1 = (real)NUM2DBL(ry1);
+    i_rx2 = (real)NUM2DBL(rx2);
+    i_ry2 = (real)NUM2DBL(ry2);
+
+
+    sglar_(&i_rx1, &i_ry1, &i_rx2, &i_ry2);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgslat(obj, itype)
+    VALUE obj, itype;
+{
+    integer i_itype;
+
+    if ((TYPE(itype) != T_BIGNUM) || (TYPE(itype) != T_FIXNUM)) {
+      itype = rb_funcall(itype, rb_intern("to_i"), 0);
+    }
+
+    i_itype = NUM2INT(itype);
+
+
+    sgslat_(&i_itype);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqlat(obj)
+    VALUE obj;
+{
+    integer o_itype;
+    VALUE itype;
+
+    sgqlat_(&o_itype);
+
+    itype = INT2NUM(o_itype);
+
+
+    return itype;
+
+}
+
+static VALUE
+dcl_sgslai(obj, index)
+    VALUE obj, index;
+{
+    integer i_index;
+
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_index = NUM2INT(index);
+
+
+    sgslai_(&i_index);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqlai(obj)
+    VALUE obj;
+{
+    integer o_index;
+    VALUE index;
+
+    sgqlai_(&o_index);
+
+    index = INT2NUM(o_index);
+
+
+    return index;
+
+}
+
+static VALUE
+dcl_sglazu(obj, ux1, uy1, ux2, uy2, itype, index)
+    VALUE obj, ux1, uy1, ux2, uy2, itype, index;
+{
+    real i_ux1;
+    real i_uy1;
+    real i_ux2;
+    real i_uy2;
+    integer i_itype;
+    integer i_index;
+
+    if (TYPE(ux1) != T_FLOAT) {
+      ux1 = rb_funcall(ux1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(uy1) != T_FLOAT) {
+      uy1 = rb_funcall(uy1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ux2) != T_FLOAT) {
+      ux2 = rb_funcall(ux2, rb_intern("to_f"), 0);
+    }
+    if (TYPE(uy2) != T_FLOAT) {
+      uy2 = rb_funcall(uy2, rb_intern("to_f"), 0);
+    }
+    if ((TYPE(itype) != T_BIGNUM) || (TYPE(itype) != T_FIXNUM)) {
+      itype = rb_funcall(itype, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_ux1 = (real)NUM2DBL(ux1);
+    i_uy1 = (real)NUM2DBL(uy1);
+    i_ux2 = (real)NUM2DBL(ux2);
+    i_uy2 = (real)NUM2DBL(uy2);
+    i_itype = NUM2INT(itype);
+    i_index = NUM2INT(index);
+
+
+    sglazu_(&i_ux1, &i_uy1, &i_ux2, &i_uy2, &i_itype, &i_index);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sglazv(obj, vx1, vy1, vx2, vy2, itype, index)
+    VALUE obj, vx1, vy1, vx2, vy2, itype, index;
+{
+    real i_vx1;
+    real i_vy1;
+    real i_vx2;
+    real i_vy2;
+    integer i_itype;
+    integer i_index;
+
+    if (TYPE(vx1) != T_FLOAT) {
+      vx1 = rb_funcall(vx1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vy1) != T_FLOAT) {
+      vy1 = rb_funcall(vy1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vx2) != T_FLOAT) {
+      vx2 = rb_funcall(vx2, rb_intern("to_f"), 0);
+    }
+    if (TYPE(vy2) != T_FLOAT) {
+      vy2 = rb_funcall(vy2, rb_intern("to_f"), 0);
+    }
+    if ((TYPE(itype) != T_BIGNUM) || (TYPE(itype) != T_FIXNUM)) {
+      itype = rb_funcall(itype, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_vx1 = (real)NUM2DBL(vx1);
+    i_vy1 = (real)NUM2DBL(vy1);
+    i_vx2 = (real)NUM2DBL(vx2);
+    i_vy2 = (real)NUM2DBL(vy2);
+    i_itype = NUM2INT(itype);
+    i_index = NUM2INT(index);
+
+
+    sglazv_(&i_vx1, &i_vy1, &i_vx2, &i_vy2, &i_itype, &i_index);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sglazr(obj, rx1, ry1, rx2, ry2, itype, index)
+    VALUE obj, rx1, ry1, rx2, ry2, itype, index;
+{
+    real i_rx1;
+    real i_ry1;
+    real i_rx2;
+    real i_ry2;
+    integer i_itype;
+    integer i_index;
+
+    if (TYPE(rx1) != T_FLOAT) {
+      rx1 = rb_funcall(rx1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ry1) != T_FLOAT) {
+      ry1 = rb_funcall(ry1, rb_intern("to_f"), 0);
+    }
+    if (TYPE(rx2) != T_FLOAT) {
+      rx2 = rb_funcall(rx2, rb_intern("to_f"), 0);
+    }
+    if (TYPE(ry2) != T_FLOAT) {
+      ry2 = rb_funcall(ry2, rb_intern("to_f"), 0);
+    }
+    if ((TYPE(itype) != T_BIGNUM) || (TYPE(itype) != T_FIXNUM)) {
+      itype = rb_funcall(itype, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(index) != T_BIGNUM) || (TYPE(index) != T_FIXNUM)) {
+      index = rb_funcall(index, rb_intern("to_i"), 0);
+    }
+
+    i_rx1 = (real)NUM2DBL(rx1);
+    i_ry1 = (real)NUM2DBL(ry1);
+    i_rx2 = (real)NUM2DBL(rx2);
+    i_ry2 = (real)NUM2DBL(ry2);
+    i_itype = NUM2INT(itype);
+    i_index = NUM2INT(index);
+
+
+    sglazr_(&i_rx1, &i_ry1, &i_rx2, &i_ry2, &i_itype, &i_index);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgsplc(obj, charx)
+    VALUE obj, charx;
+{
+    char *i_charx;
+
+    if (TYPE(charx) != T_STRING) {
+      charx = rb_funcall(charx, rb_intern("to_str"), 0);
+    }
+
+    i_charx = StringValuePtr(charx);
+
+
+    sgsplc_(i_charx, (ftnlen)strlen(i_charx));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqplc(obj)
+    VALUE obj;
+{
+    char *o_charx;
+    VALUE charx;
+
+    o_charx= ALLOCA_N(char, (DFLT_SIZE+1));
+    memset(o_charx, '\0', DFLT_SIZE+1);
+
+    sgqplc_(o_charx, (ftnlen)DFLT_SIZE);
+
+    charx = rb_str_new2(o_charx);
+
+
+    return charx;
+
+}
+
+static VALUE
+dcl_sgspls(obj, rsize)
+    VALUE obj, rsize;
+{
+    real i_rsize;
+
+    if (TYPE(rsize) != T_FLOAT) {
+      rsize = rb_funcall(rsize, rb_intern("to_f"), 0);
+    }
+
+    i_rsize = (real)NUM2DBL(rsize);
+
+
+    sgspls_(&i_rsize);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgqpls(obj)
+    VALUE obj;
+{
+    real o_rsize;
+    VALUE rsize;
+
+    sgqpls_(&o_rsize);
+
+    rsize = rb_float_new((double)o_rsize);
+
+
+    return rsize;
+
+}
+
+static VALUE
+dcl_sgnplc(obj)
+    VALUE obj;
+{
+    sgnplc_();
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgiget(obj, cp)
+    VALUE obj, cp;
+{
+    char *i_cp;
+    integer o_ipara;
+    VALUE ipara;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+
+
+    sgiget_(i_cp, &o_ipara, (ftnlen)strlen(i_cp));
+
+    ipara = INT2NUM(o_ipara);
+
+
+    return ipara;
+
+}
+
+static VALUE
+dcl_sgiset(obj, cp, ipara)
+    VALUE obj, cp, ipara;
+{
+    char *i_cp;
+    integer i_ipara;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+    if ((TYPE(ipara) != T_BIGNUM) || (TYPE(ipara) != T_FIXNUM)) {
+      ipara = rb_funcall(ipara, rb_intern("to_i"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+    i_ipara = NUM2INT(ipara);
+
+
+    sgiset_(i_cp, &i_ipara, (ftnlen)strlen(i_cp));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgistx(obj, cp, ipara)
+    VALUE obj, cp, ipara;
+{
+    char *i_cp;
+    integer i_ipara;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+    if ((TYPE(ipara) != T_BIGNUM) || (TYPE(ipara) != T_FIXNUM)) {
+      ipara = rb_funcall(ipara, rb_intern("to_i"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+    i_ipara = NUM2INT(ipara);
+
+
+    sgistx_(i_cp, &i_ipara, (ftnlen)strlen(i_cp));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgiqnp(obj)
+    VALUE obj;
+{
+    integer o_ncp;
+    VALUE ncp;
+
+    sgiqnp_(&o_ncp);
+
+    ncp = INT2NUM(o_ncp);
+
+
+    return ncp;
+
+}
+
+static VALUE
+dcl_sgiqid(obj, cp)
+    VALUE obj, cp;
+{
+    char *i_cp;
+    integer o_idx;
+    VALUE idx;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+
+
+    sgiqid_(i_cp, &o_idx, (ftnlen)strlen(i_cp));
+
+    idx = INT2NUM(o_idx);
+
+
+    return idx;
+
+}
+
+static VALUE
+dcl_sgiqcp(obj, idx)
+    VALUE obj, idx;
+{
+    integer i_idx;
+    char *o_cp;
+    VALUE cp;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+
+    o_cp= ALLOCA_N(char, (DFLT_SIZE+1));
+    memset(o_cp, '\0', DFLT_SIZE+1);
+
+    sgiqcp_(&i_idx, o_cp, (ftnlen)DFLT_SIZE);
+
+    cp = rb_str_new2(o_cp);
+
+
+    return cp;
+
+}
+
+static VALUE
+dcl_sgiqcl(obj, idx)
+    VALUE obj, idx;
+{
+    integer i_idx;
+    char *o_cp;
+    VALUE cp;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+
+    o_cp= ALLOCA_N(char, (DFLT_SIZE+1));
+    memset(o_cp, '\0', DFLT_SIZE+1);
+
+    sgiqcl_(&i_idx, o_cp, (ftnlen)DFLT_SIZE);
+
+    cp = rb_str_new2(o_cp);
+
+
+    return cp;
+
+}
+
+static VALUE
+dcl_sgiqvl(obj, idx)
+    VALUE obj, idx;
+{
+    integer i_idx;
+    integer o_ipara;
+    VALUE ipara;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+
+
+    sgiqvl_(&i_idx, &o_ipara);
+
+    ipara = INT2NUM(o_ipara);
+
+
+    return ipara;
+
+}
+
+static VALUE
+dcl_sgisvl(obj, idx, ipara)
+    VALUE obj, idx, ipara;
+{
+    integer i_idx;
+    integer i_ipara;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+    if ((TYPE(ipara) != T_BIGNUM) || (TYPE(ipara) != T_FIXNUM)) {
+      ipara = rb_funcall(ipara, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+    i_ipara = NUM2INT(ipara);
+
+
+    sgisvl_(&i_idx, &i_ipara);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgiqin(obj, cp)
+    VALUE obj, cp;
+{
+    char *i_cp;
+    integer o_in;
+    VALUE in;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+
+
+    sgiqin_(i_cp, &o_in, (ftnlen)strlen(i_cp));
+
+    in = INT2NUM(o_in);
+
+
+    return in;
+
+}
+
+static VALUE
+dcl_sglget(obj, cp)
+    VALUE obj, cp;
+{
+    char *i_cp;
+    logical o_lpara;
+    VALUE lpara;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+
+
+    sglget_(i_cp, &o_lpara, (ftnlen)strlen(i_cp));
+
+    lpara = (o_lpara == FALSE_) ? Qfalse : Qtrue;
+
+
+    return lpara;
+
+}
+
+static VALUE
+dcl_sglset(obj, cp, lpara)
+    VALUE obj, cp, lpara;
+{
+    char *i_cp;
+    logical i_lpara;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+    i_lpara = ((lpara == Qnil)||(lpara == Qfalse)) ? FALSE_ : TRUE_;
+
+
+    sglset_(i_cp, &i_lpara, (ftnlen)strlen(i_cp));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sglstx(obj, cp, lpara)
+    VALUE obj, cp, lpara;
+{
+    char *i_cp;
+    logical i_lpara;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+    i_lpara = ((lpara == Qnil)||(lpara == Qfalse)) ? FALSE_ : TRUE_;
+
+
+    sglstx_(i_cp, &i_lpara, (ftnlen)strlen(i_cp));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sglqnp(obj)
+    VALUE obj;
+{
+    integer o_ncp;
+    VALUE ncp;
+
+    sglqnp_(&o_ncp);
+
+    ncp = INT2NUM(o_ncp);
+
+
+    return ncp;
+
+}
+
+static VALUE
+dcl_sglqid(obj, cp)
+    VALUE obj, cp;
+{
+    char *i_cp;
+    integer o_idx;
+    VALUE idx;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+
+
+    sglqid_(i_cp, &o_idx, (ftnlen)strlen(i_cp));
+
+    idx = INT2NUM(o_idx);
+
+
+    return idx;
+
+}
+
+static VALUE
+dcl_sglqcp(obj, idx)
+    VALUE obj, idx;
+{
+    integer i_idx;
+    char *o_cp;
+    VALUE cp;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+
+    o_cp= ALLOCA_N(char, (DFLT_SIZE+1));
+    memset(o_cp, '\0', DFLT_SIZE+1);
+
+    sglqcp_(&i_idx, o_cp, (ftnlen)DFLT_SIZE);
+
+    cp = rb_str_new2(o_cp);
+
+
+    return cp;
+
+}
+
+static VALUE
+dcl_sglqcl(obj, idx)
+    VALUE obj, idx;
+{
+    integer i_idx;
+    char *o_cp;
+    VALUE cp;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+
+    o_cp= ALLOCA_N(char, (DFLT_SIZE+1));
+    memset(o_cp, '\0', DFLT_SIZE+1);
+
+    sglqcl_(&i_idx, o_cp, (ftnlen)DFLT_SIZE);
+
+    cp = rb_str_new2(o_cp);
+
+
+    return cp;
+
+}
+
+static VALUE
+dcl_sglqvl(obj, idx)
+    VALUE obj, idx;
+{
+    integer i_idx;
+    logical o_lpara;
+    VALUE lpara;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+
+
+    sglqvl_(&i_idx, &o_lpara);
+
+    lpara = (o_lpara == FALSE_) ? Qfalse : Qtrue;
+
+
+    return lpara;
+
+}
+
+static VALUE
+dcl_sglsvl(obj, idx, lpara)
+    VALUE obj, idx, lpara;
+{
+    integer i_idx;
+    logical i_lpara;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+    i_lpara = ((lpara == Qnil)||(lpara == Qfalse)) ? FALSE_ : TRUE_;
+
+
+    sglsvl_(&i_idx, &i_lpara);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sglqin(obj, cp)
+    VALUE obj, cp;
+{
+    char *i_cp;
+    integer o_in;
+    VALUE in;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+
+
+    sglqin_(i_cp, &o_in, (ftnlen)strlen(i_cp));
+
+    in = INT2NUM(o_in);
+
+
+    return in;
+
+}
+
+static VALUE
+dcl_sgoopn(obj, cprc, com)
+    VALUE obj, cprc, com;
+{
+    char *i_cprc;
+    char *i_com;
+
+    if (TYPE(cprc) != T_STRING) {
+      cprc = rb_funcall(cprc, rb_intern("to_str"), 0);
+    }
+    if (TYPE(com) != T_STRING) {
+      com = rb_funcall(com, rb_intern("to_str"), 0);
+    }
+
+    i_cprc = StringValuePtr(cprc);
+    i_com = StringValuePtr(com);
+
+
+    sgoopn_(i_cprc, i_com, (ftnlen)strlen(i_cprc), (ftnlen)strlen(i_com));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgocls(obj, cprc)
+    VALUE obj, cprc;
+{
+    char *i_cprc;
+
+    if (TYPE(cprc) != T_STRING) {
+      cprc = rb_funcall(cprc, rb_intern("to_str"), 0);
+    }
+
+    i_cprc = StringValuePtr(cprc);
+
+
+    sgocls_(i_cprc, (ftnlen)strlen(i_cprc));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgrget(obj, cp)
+    VALUE obj, cp;
+{
+    char *i_cp;
+    real o_rpara;
+    VALUE rpara;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+
+
+    sgrget_(i_cp, &o_rpara, (ftnlen)strlen(i_cp));
+
+    rpara = rb_float_new((double)o_rpara);
+
+
+    return rpara;
+
+}
+
+static VALUE
+dcl_sgrset(obj, cp, rpara)
+    VALUE obj, cp, rpara;
+{
+    char *i_cp;
+    real i_rpara;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+    if (TYPE(rpara) != T_FLOAT) {
+      rpara = rb_funcall(rpara, rb_intern("to_f"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+    i_rpara = (real)NUM2DBL(rpara);
+
+
+    sgrset_(i_cp, &i_rpara, (ftnlen)strlen(i_cp));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgrstx(obj, cp, rpara)
+    VALUE obj, cp, rpara;
+{
+    char *i_cp;
+    real i_rpara;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+    if (TYPE(rpara) != T_FLOAT) {
+      rpara = rb_funcall(rpara, rb_intern("to_f"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+    i_rpara = (real)NUM2DBL(rpara);
+
+
+    sgrstx_(i_cp, &i_rpara, (ftnlen)strlen(i_cp));
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgrqnp(obj)
+    VALUE obj;
+{
+    integer o_ncp;
+    VALUE ncp;
+
+    sgrqnp_(&o_ncp);
+
+    ncp = INT2NUM(o_ncp);
+
+
+    return ncp;
+
+}
+
+static VALUE
+dcl_sgrqid(obj, cp)
+    VALUE obj, cp;
+{
+    char *i_cp;
+    integer o_idx;
+    VALUE idx;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+
+
+    sgrqid_(i_cp, &o_idx, (ftnlen)strlen(i_cp));
+
+    idx = INT2NUM(o_idx);
+
+
+    return idx;
+
+}
+
+static VALUE
+dcl_sgrqcp(obj, idx)
+    VALUE obj, idx;
+{
+    integer i_idx;
+    char *o_cp;
+    VALUE cp;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+
+    o_cp= ALLOCA_N(char, (DFLT_SIZE+1));
+    memset(o_cp, '\0', DFLT_SIZE+1);
+
+    sgrqcp_(&i_idx, o_cp, (ftnlen)DFLT_SIZE);
+
+    cp = rb_str_new2(o_cp);
+
+
+    return cp;
+
+}
+
+static VALUE
+dcl_sgrqcl(obj, idx)
+    VALUE obj, idx;
+{
+    integer i_idx;
+    char *o_cp;
+    VALUE cp;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+
+    o_cp= ALLOCA_N(char, (DFLT_SIZE+1));
+    memset(o_cp, '\0', DFLT_SIZE+1);
+
+    sgrqcl_(&i_idx, o_cp, (ftnlen)DFLT_SIZE);
+
+    cp = rb_str_new2(o_cp);
+
+
+    return cp;
+
+}
+
+static VALUE
+dcl_sgrqvl(obj, idx)
+    VALUE obj, idx;
+{
+    integer i_idx;
+    real o_rpara;
+    VALUE rpara;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+
+
+    sgrqvl_(&i_idx, &o_rpara);
+
+    rpara = rb_float_new((double)o_rpara);
+
+
+    return rpara;
+
+}
+
+static VALUE
+dcl_sgrsvl(obj, idx, rpara)
+    VALUE obj, idx, rpara;
+{
+    integer i_idx;
+    real i_rpara;
+
+    if ((TYPE(idx) != T_BIGNUM) || (TYPE(idx) != T_FIXNUM)) {
+      idx = rb_funcall(idx, rb_intern("to_i"), 0);
+    }
+    if (TYPE(rpara) != T_FLOAT) {
+      rpara = rb_funcall(rpara, rb_intern("to_f"), 0);
+    }
+
+    i_idx = NUM2INT(idx);
+    i_rpara = (real)NUM2DBL(rpara);
+
+
+    sgrsvl_(&i_idx, &i_rpara);
+
+    return Qnil;
+
+}
+
+static VALUE
+dcl_sgrqin(obj, cp)
+    VALUE obj, cp;
+{
+    char *i_cp;
+    integer o_in;
+    VALUE in;
+
+    if (TYPE(cp) != T_STRING) {
+      cp = rb_funcall(cp, rb_intern("to_str"), 0);
+    }
+
+    i_cp = StringValuePtr(cp);
+
+
+    sgrqin_(i_cp, &o_in, (ftnlen)strlen(i_cp));
+
+    in = INT2NUM(o_in);
+
+
+    return in;
+
+}
+
+#if DCLVER >= 530
+
+static VALUE
+dcl_sgpcmd(obj)
+    VALUE obj;
+{
+    sgpcmd_();
+
+    return Qnil;
+
+}
+
+#endif
+
+#if DCLVER >= 530
+
+static VALUE
+dcl_sgscmn(obj, nc)
+    VALUE obj, nc;
+{
+    integer i_nc;
+
+    if ((TYPE(nc) != T_BIGNUM) || (TYPE(nc) != T_FIXNUM)) {
+      nc = rb_funcall(nc, rb_intern("to_i"), 0);
+    }
+
+    i_nc = NUM2INT(nc);
+
+
+    sgscmn_(&i_nc);
+
+    return Qnil;
+
+}
+
+#endif
+
+#if DCLVER >= 530
+
+static VALUE
+dcl_sgqcmn(obj)
+    VALUE obj;
+{
+    integer o_nmax;
+    VALUE nmax;
+
+    sgqcmn_(&o_nmax);
+
+    nmax = INT2NUM(o_nmax);
+
+
+    return nmax;
+
+}
+
+#endif
+
+#if DCLVER >= 530
+
+static VALUE
+dcl_sgscwd(obj, cxmin, cxmax, cymin, cymax)
+    VALUE obj, cxmin, cxmax, cymin, cymax;
+{
+    real i_cxmin;
+    real i_cxmax;
+    real i_cymin;
+    real i_cymax;
+
+    if (TYPE(cxmin) != T_FLOAT) {
+      cxmin = rb_funcall(cxmin, rb_intern("to_f"), 0);
+    }
+    if (TYPE(cxmax) != T_FLOAT) {
+      cxmax = rb_funcall(cxmax, rb_intern("to_f"), 0);
+    }
+    if (TYPE(cymin) != T_FLOAT) {
+      cymin = rb_funcall(cymin, rb_intern("to_f"), 0);
+    }
+    if (TYPE(cymax) != T_FLOAT) {
+      cymax = rb_funcall(cymax, rb_intern("to_f"), 0);
+    }
+
+    i_cxmin = (real)NUM2DBL(cxmin);
+    i_cxmax = (real)NUM2DBL(cxmax);
+    i_cymin = (real)NUM2DBL(cymin);
+    i_cymax = (real)NUM2DBL(cymax);
+
+
+    sgscwd_(&i_cxmin, &i_cxmax, &i_cymin, &i_cymax);
+
+    return Qnil;
+
+}
+
+#endif
+
+#if DCLVER >= 530
+
+static VALUE
+dcl_sgqcwd(obj)
+    VALUE obj;
+{
+    real o_cxmin;
+    real o_cxmax;
+    real o_cymin;
+    real o_cymax;
+    VALUE cxmin;
+    VALUE cxmax;
+    VALUE cymin;
+    VALUE cymax;
+
+    sgqcwd_(&o_cxmin, &o_cxmax, &o_cymin, &o_cymax);
+
+    cxmin = rb_float_new((double)o_cxmin);
+    cxmax = rb_float_new((double)o_cxmax);
+    cymin = rb_float_new((double)o_cymin);
+    cymax = rb_float_new((double)o_cymax);
+
+
+    return rb_ary_new3(4, cxmin, cxmax, cymin, cymax);
+
+}
+
+#endif
+void
+init_grph1_sgpack(mDCL)
+VALUE mDCL;
+{
+    rb_define_module_function(mDCL, "sgopn", dcl_sgopn, 1);
+    rb_define_module_function(mDCL, "sgfrm", dcl_sgfrm, 0);
+    rb_define_module_function(mDCL, "sgcls", dcl_sgcls, 0);
+    rb_define_module_function(mDCL, "sgpqnp", dcl_sgpqnp, 0);
+    rb_define_module_function(mDCL, "sgpqid", dcl_sgpqid, 1);
+    rb_define_module_function(mDCL, "sgpqcp", dcl_sgpqcp, 1);
+    rb_define_module_function(mDCL, "sgpqcl", dcl_sgpqcl, 1);
+    rb_define_module_function(mDCL, "sgpqit", dcl_sgpqit, 1);
+    rb_define_module_function(mDCL, "sgpqvl", dcl_sgpqvl, 1);
+    rb_define_module_function(mDCL, "sgpsvl", dcl_sgpsvl, 2);
+    rb_define_module_function(mDCL, "sgpqin", dcl_sgpqin, 1);
+    rb_define_module_function(mDCL, "sgpwsn", dcl_sgpwsn, 0);
+    rb_define_module_function(mDCL, "sgsvpt", dcl_sgsvpt, 4);
+    rb_define_module_function(mDCL, "sgqvpt", dcl_sgqvpt, 0);
+    rb_define_module_function(mDCL, "sgswnd", dcl_sgswnd, 4);
+    rb_define_module_function(mDCL, "sgqwnd", dcl_sgqwnd, 0);
+    rb_define_module_function(mDCL, "sgssim", dcl_sgssim, 3);
+    rb_define_module_function(mDCL, "sgqsim", dcl_sgqsim, 0);
+    rb_define_module_function(mDCL, "sgsmpl", dcl_sgsmpl, 3);
+    rb_define_module_function(mDCL, "sgqmpl", dcl_sgqmpl, 0);
+    rb_define_module_function(mDCL, "sgstxy", dcl_sgstxy, 4);
+    rb_define_module_function(mDCL, "sgqtxy", dcl_sgqtxy, 0);
+    rb_define_module_function(mDCL, "sgstrn", dcl_sgstrn, 1);
+    rb_define_module_function(mDCL, "sgqtrn", dcl_sgqtrn, 0);
+    rb_define_module_function(mDCL, "sgstrf", dcl_sgstrf, 0);
+    rb_define_module_function(mDCL, "sgtrqf", dcl_sgtrqf, 1);
+    rb_define_module_function(mDCL, "sgtrsl", dcl_sgtrsl, 1);
+    rb_define_module_function(mDCL, "sgtrsn", dcl_sgtrsn, 1);
+    rb_define_module_function(mDCL, "sgtrls", dcl_sgtrls, 1);
+    rb_define_module_function(mDCL, "sgtrln", dcl_sgtrln, 1);
+    rb_define_module_function(mDCL, "sgtrns", dcl_sgtrns, 1);
+    rb_define_module_function(mDCL, "sgtrnl", dcl_sgtrnl, 1);
+    rb_define_module_function(mDCL, "isgtrc", dcl_isgtrc, 1);
+    rb_define_module_function(mDCL, "sgplu", dcl_sgplu, 3);
+    rb_define_module_function(mDCL, "sgplv", dcl_sgplv, 3);
+    rb_define_module_function(mDCL, "sgplr", dcl_sgplr, 3);
+    rb_define_module_function(mDCL, "sgsplt", dcl_sgsplt, 1);
+    rb_define_module_function(mDCL, "sgqplt", dcl_sgqplt, 0);
+    rb_define_module_function(mDCL, "sgspli", dcl_sgspli, 1);
+    rb_define_module_function(mDCL, "sgqpli", dcl_sgqpli, 0);
+    rb_define_module_function(mDCL, "sgplzu", dcl_sgplzu, 5);
+    rb_define_module_function(mDCL, "sgplzv", dcl_sgplzv, 5);
+    rb_define_module_function(mDCL, "sgplzr", dcl_sgplzr, 5);
+    rb_define_module_function(mDCL, "sgpmu", dcl_sgpmu, 3);
+    rb_define_module_function(mDCL, "sgpmv", dcl_sgpmv, 3);
+    rb_define_module_function(mDCL, "sgpmr", dcl_sgpmr, 3);
+    rb_define_module_function(mDCL, "sgspmt", dcl_sgspmt, 1);
+    rb_define_module_function(mDCL, "sgqpmt", dcl_sgqpmt, 0);
+    rb_define_module_function(mDCL, "sgspmi", dcl_sgspmi, 1);
+    rb_define_module_function(mDCL, "sgqpmi", dcl_sgqpmi, 0);
+    rb_define_module_function(mDCL, "sgspms", dcl_sgspms, 1);
+    rb_define_module_function(mDCL, "sgqpms", dcl_sgqpms, 0);
+    rb_define_module_function(mDCL, "sgtxu", dcl_sgtxu, 3);
+    rb_define_module_function(mDCL, "sgtxv", dcl_sgtxv, 3);
+    rb_define_module_function(mDCL, "sgtxr", dcl_sgtxr, 3);
+    rb_define_module_function(mDCL, "sgstxs", dcl_sgstxs, 1);
+    rb_define_module_function(mDCL, "sgqtxs", dcl_sgqtxs, 0);
+    rb_define_module_function(mDCL, "sgstxr", dcl_sgstxr, 1);
+    rb_define_module_function(mDCL, "sgqtxr", dcl_sgqtxr, 0);
+    rb_define_module_function(mDCL, "sgstxc", dcl_sgstxc, 1);
+    rb_define_module_function(mDCL, "sgqtxc", dcl_sgqtxc, 0);
+    rb_define_module_function(mDCL, "sgstxi", dcl_sgstxi, 1);
+    rb_define_module_function(mDCL, "sgqtxi", dcl_sgqtxi, 0);
+    rb_define_module_function(mDCL, "sgpmzu", dcl_sgpmzu, 6);
+    rb_define_module_function(mDCL, "sgpmzv", dcl_sgpmzv, 6);
+    rb_define_module_function(mDCL, "sgpmzr", dcl_sgpmzr, 6);
+    rb_define_module_function(mDCL, "sgtxzu", dcl_sgtxzu, 7);
+    rb_define_module_function(mDCL, "sgtxzv", dcl_sgtxzv, 7);
+    rb_define_module_function(mDCL, "sgtxzr", dcl_sgtxzr, 7);
+    rb_define_module_function(mDCL, "sgtnu", dcl_sgtnu, 3);
+    rb_define_module_function(mDCL, "sgtnv", dcl_sgtnv, 3);
+    rb_define_module_function(mDCL, "sgtnr", dcl_sgtnr, 3);
+    rb_define_module_function(mDCL, "sgstnp", dcl_sgstnp, 1);
+    rb_define_module_function(mDCL, "sgqtnp", dcl_sgqtnp, 0);
+    rb_define_module_function(mDCL, "sgtnzu", dcl_sgtnzu, 4);
+    rb_define_module_function(mDCL, "sgtnzv", dcl_sgtnzv, 4);
+    rb_define_module_function(mDCL, "sgtnzr", dcl_sgtnzr, 4);
+    rb_define_module_function(mDCL, "sglnu", dcl_sglnu, 4);
+    rb_define_module_function(mDCL, "sglnv", dcl_sglnv, 4);
+    rb_define_module_function(mDCL, "sglnr", dcl_sglnr, 4);
+    rb_define_module_function(mDCL, "sgslni", dcl_sgslni, 1);
+    rb_define_module_function(mDCL, "sgqlni", dcl_sgqlni, 0);
+    rb_define_module_function(mDCL, "sglnzu", dcl_sglnzu, 5);
+    rb_define_module_function(mDCL, "sglnzv", dcl_sglnzv, 5);
+    rb_define_module_function(mDCL, "sglnzr", dcl_sglnzr, 5);
+    rb_define_module_function(mDCL, "sglau", dcl_sglau, 4);
+    rb_define_module_function(mDCL, "sglav", dcl_sglav, 4);
+    rb_define_module_function(mDCL, "sglar", dcl_sglar, 4);
+    rb_define_module_function(mDCL, "sgslat", dcl_sgslat, 1);
+    rb_define_module_function(mDCL, "sgqlat", dcl_sgqlat, 0);
+    rb_define_module_function(mDCL, "sgslai", dcl_sgslai, 1);
+    rb_define_module_function(mDCL, "sgqlai", dcl_sgqlai, 0);
+    rb_define_module_function(mDCL, "sglazu", dcl_sglazu, 6);
+    rb_define_module_function(mDCL, "sglazv", dcl_sglazv, 6);
+    rb_define_module_function(mDCL, "sglazr", dcl_sglazr, 6);
+    rb_define_module_function(mDCL, "sgsplc", dcl_sgsplc, 1);
+    rb_define_module_function(mDCL, "sgqplc", dcl_sgqplc, 0);
+    rb_define_module_function(mDCL, "sgspls", dcl_sgspls, 1);
+    rb_define_module_function(mDCL, "sgqpls", dcl_sgqpls, 0);
+    rb_define_module_function(mDCL, "sgnplc", dcl_sgnplc, 0);
+    rb_define_module_function(mDCL, "sgiget", dcl_sgiget, 1);
+    rb_define_module_function(mDCL, "sgiset", dcl_sgiset, 2);
+    rb_define_module_function(mDCL, "sgistx", dcl_sgistx, 2);
+    rb_define_module_function(mDCL, "sgiqnp", dcl_sgiqnp, 0);
+    rb_define_module_function(mDCL, "sgiqid", dcl_sgiqid, 1);
+    rb_define_module_function(mDCL, "sgiqcp", dcl_sgiqcp, 1);
+    rb_define_module_function(mDCL, "sgiqcl", dcl_sgiqcl, 1);
+    rb_define_module_function(mDCL, "sgiqvl", dcl_sgiqvl, 1);
+    rb_define_module_function(mDCL, "sgisvl", dcl_sgisvl, 2);
+    rb_define_module_function(mDCL, "sgiqin", dcl_sgiqin, 1);
+    rb_define_module_function(mDCL, "sglget", dcl_sglget, 1);
+    rb_define_module_function(mDCL, "sglset", dcl_sglset, 2);
+    rb_define_module_function(mDCL, "sglstx", dcl_sglstx, 2);
+    rb_define_module_function(mDCL, "sglqnp", dcl_sglqnp, 0);
+    rb_define_module_function(mDCL, "sglqid", dcl_sglqid, 1);
+    rb_define_module_function(mDCL, "sglqcp", dcl_sglqcp, 1);
+    rb_define_module_function(mDCL, "sglqcl", dcl_sglqcl, 1);
+    rb_define_module_function(mDCL, "sglqvl", dcl_sglqvl, 1);
+    rb_define_module_function(mDCL, "sglsvl", dcl_sglsvl, 2);
+    rb_define_module_function(mDCL, "sglqin", dcl_sglqin, 1);
+    rb_define_module_function(mDCL, "sgoopn", dcl_sgoopn, 2);
+    rb_define_module_function(mDCL, "sgocls", dcl_sgocls, 1);
+    rb_define_module_function(mDCL, "sgrget", dcl_sgrget, 1);
+    rb_define_module_function(mDCL, "sgrset", dcl_sgrset, 2);
+    rb_define_module_function(mDCL, "sgrstx", dcl_sgrstx, 2);
+    rb_define_module_function(mDCL, "sgrqnp", dcl_sgrqnp, 0);
+    rb_define_module_function(mDCL, "sgrqid", dcl_sgrqid, 1);
+    rb_define_module_function(mDCL, "sgrqcp", dcl_sgrqcp, 1);
+    rb_define_module_function(mDCL, "sgrqcl", dcl_sgrqcl, 1);
+    rb_define_module_function(mDCL, "sgrqvl", dcl_sgrqvl, 1);
+    rb_define_module_function(mDCL, "sgrsvl", dcl_sgrsvl, 2);
+    rb_define_module_function(mDCL, "sgrqin", dcl_sgrqin, 1);
+#if DCLVER >= 530
+    rb_define_module_function(mDCL, "sgpcmd", dcl_sgpcmd, 0);
+#endif
+#if DCLVER >= 530
+    rb_define_module_function(mDCL, "sgscmn", dcl_sgscmn, 1);
+#endif
+#if DCLVER >= 530
+    rb_define_module_function(mDCL, "sgqcmn", dcl_sgqcmn, 0);
+#endif
+#if DCLVER >= 530
+    rb_define_module_function(mDCL, "sgscwd", dcl_sgscwd, 4);
+#endif
+#if DCLVER >= 530
+    rb_define_module_function(mDCL, "sgqcwd", dcl_sgqcwd, 0);
+#endif
+}