alglib 1.0.0 → 1.0.1

data/History.txt

@@ -1,3 +1,7 @@
+=== 1.0.1 / 2009-08-20
+* Logit class. Implemented Logit#process and Logit#unpack.
+* Correlation. Implemented Alglib.pearson_correlation and Alglib.spearman_correlation
+
 === 1.0.0 / 2009-07-28
 
 * First version of Alglib. Only Multiple Regression Implemented

data/Manifest.txt

@@ -238,6 +238,16 @@ ext/alglib/variancetests.cpp
 ext/alglib/variancetests.h
 ext/alglib/wsr.cpp
 ext/alglib/wsr.h
+ext/ap.i
+ext/correlation.i
 ext/extconf.rb
+ext/logit.i
 lib/alglib.rb
+lib/alglib/correlation.rb
+lib/alglib/linearregression.rb
+lib/alglib/logit.rb
 test/test_alglib.rb
+test/test_correlation.rb
+test/test_correlationtest.rb
+test/test_linreg.rb
+test/test_logit.rb

data/README.txt

@@ -9,7 +9,7 @@ ALGLIB - is a multilingual collection of algorithms designed to solve problems i
 
 == FEATURES/PROBLEMS:
 
-* Only Multiple regression  Implemented
+* Only Multiple regression,  Logit Regression and Correlation implemented
 
 
 == SYNOPSIS:

data/Rakefile

@@ -1,3 +1,4 @@
+#!/usr/bin/ruby
 # -*- ruby -*-
 
 require 'rubygems'
@@ -10,7 +11,7 @@ file "ext/Makefile" => "ext/extconf.rb" do |t|
     system %(cd ext && ruby extconf.rb)
 end
 
-file "ext/alglib_ext.so" => ["ext/Makefile","ext/alglib.i"] do |t|
+file "ext/alglib_ext.so" => Dir.glob("ext/*.i")+["ext/Makefile", "ext/alglib/alglib_util.cpp", "ext/alglib/alglib_util.h"] do |t|
     system %(cd ext && rake)
     
 end

data/ext/Rakefile

@@ -7,12 +7,14 @@ task :test => ["test.rb"] do |t|
     system %(ruby test.rb)
 end
 task :compile => ["alglib.so"]
-file "alglib/alglib.cpp"=>["alglib.i"] do |t|
-puts "Reconstruyendo swig"
+
+file "alglib/alglib.cpp"=>Dir.glob("*.i") do |t|
+    puts "Reconstruyendo swig"
 	system %(swig -fvirtual -Wall -c++ -o alglib/alglib.cpp -ruby alglib.i)
 end
-cpp=Dir.glob("alglib/*.cpp")+Dir.glob("alglib/*.h")
 
+
+cpp=Dir.glob("alglib/*.cpp")+Dir.glob("alglib/*.h")
 file "alglib.so"=>cpp + ["Makefile"] do |t|
 	system %(make)
 end

data/ext/alglib.i

@@ -1,160 +1,23 @@
 %module alglib_ext
 %{
 #include "ap.h"
-#include "linreg.h"
 #include "alglib_util.h"
 #include "iostream"
+
 %}
 
 %include "typemaps.i"
 %apply int *OUTPUT {int& info};
 %apply int *INPUT {int& nvars};
+%apply int *INPUT {int& nvars};
+%apply int *INPUT {int& nclasses};
+%apply double *INPUT {double &bothtails};
+%apply double *INPUT {double &lefttail};
+%apply double *INPUT {double &righttail};
 
-%typemap(in) ap::real_1d_array {
-    $1 = new ap::real_1d_array();
-    $1->setlength(RARRAY_LEN($input));
-    for(long i=0;i<RARRAY_LEN($input);i++) {
-        $1->operator()(i)=rb_num2dbl(RARRAY_PTR($input)[i]);
-    }
-}
-
-
-%apply  ap::real_1d_array {ap::real_1d_array const &};
-
-namespace ap {
-/********************************************************************
-Template of a dynamical one-dimensional array
-********************************************************************/
-template<class T, bool Aligned = false>
-class template_1d_array
-{
-public:
-    template_1d_array();
-    ~template_1d_array();
-    template_1d_array(const template_1d_array &rhs);
-    %extend {
-        T __getitem__(int i) {
-            return $self->operator()(i);
-        };
-        T __setitem__(int i, T v) {
-            return $self->operator()(i)=v;
-        };
-        int size() {
-            return $self->gethighbound()-$self->getlowbound();
-        }
-    }
-    
-    void setbounds( int iLow, int iHigh );
-    void setlength(int iLen);
-    void setcontent( int iLow, int iHigh, const T *pContent );
-    T* getcontent();
-    int getlowbound(int iBoundNum = 0);
-    int gethighbound(int iBoundNum = 0);
-};
-
-template<class T, bool Aligned = false>
-class template_2d_array
-{
-public:
-    template_2d_array();
-
-    ~template_2d_array();
-
-    template_2d_array(const template_2d_array &rhs);
-    T& operator()(int i1, int i2);
-    
-    void setbounds( int iLow1, int iHigh1, int iLow2, int iHigh2 );
-
-    void setlength(int iLen1, int iLen2);
-
-    void setcontent( int iLow1, int iHigh1, int iLow2, int iHigh2, const T *pContent );
-
-    int getlowbound(int iBoundNum) const;
-
-    int gethighbound(int iBoundNum) const;
-    
-    %extend {
-    double __getitem__(int x,int y) {
-        return $self->operator()(x,y);
-    }
-    void __setitem__(int x,int y, T val) {
-        $self->operator()(x,y)=val;
-    }
-
-}
-    
-};
-
-
-
-typedef template_1d_array<int>          integer_1d_array;
-typedef template_1d_array<double,true>  real_1d_array;
-typedef template_1d_array<complex>      complex_1d_array;
-typedef template_1d_array<bool>         boolean_1d_array;
-
-typedef template_2d_array<int>          integer_2d_array;
-typedef template_2d_array<double,true>  real_2d_array;
-typedef template_2d_array<complex>      complex_2d_array;
-typedef template_2d_array<bool>         boolean_2d_array;
-
-%template(Integer1dArray) template_1d_array<int>;
-%template(Real1dArray) template_1d_array<double,true>;
-%template(Boolean1dArray) template_1d_array<bool>;
-%template(Integer2dArray) template_2d_array<int>;
-%template(Real2dArray) template_2d_array<double,true>;
-};
-
-%rename (LinearModel) linearmodel;
-%rename (LrReport) lrreport;
-
-struct linearmodel
-{
-    ap::real_1d_array w;
-};
-struct lrreport
-{
-    ap::real_2d_array c;
-    double rmserror;
-    double avgerror;
-    double avgrelerror;
-    double cvrmserror;
-    double cvavgerror;
-    double cvavgrelerror;
-    int ncvdefects;
-    ap::integer_1d_array cvdefects;
-};
-
-
-void lrbuild(const ap::real_2d_array& xy,
-     int npoints,
-     int nvars,
-     int& info,
-     linearmodel& lm,
-     lrreport& ar);
 
-void lrbuilds(const ap::real_2d_array& xy,
-     const ap::real_1d_array& s,
-     int npoints,
-     int nvars,
-     int& info,
-     linearmodel& lm,
-     lrreport& ar);
-     
-void lrbuildzs(const ap::real_2d_array& xy,
-     const ap::real_1d_array& s,
-     int npoints,
-     int nvars,
-     int& info,
-     linearmodel& lm,
-     lrreport& ar);
-void lrbuildz(const ap::real_2d_array& xy,
-     int npoints,
-     int nvars,
-     int& info,
-     linearmodel& lm,
-     lrreport& ar);
-     
-void lrunpack(const linearmodel& lm, ap::real_1d_array& v, int& nvars);
-void lrpack(const ap::real_1d_array& v, int nvars, linearmodel& lm);
-double lrprocess(const linearmodel& lm, const ap::real_1d_array& x);
-VALUE real1d_to_array(ap::real_1d_array *x);
+%include "ap.i"
+%include "correlation.i"
+%include "correlationtests.i"
+%include "linreg.i"
+%include "logit.i"

data/ext/alglib/alglib.cpp

@@ -1784,9 +1784,12 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 #define SWIGTYPE_p_double swig_types[10]
 #define SWIGTYPE_p_int swig_types[11]
 #define SWIGTYPE_p_linearmodel swig_types[12]
-#define SWIGTYPE_p_lrreport swig_types[13]
-static swig_type_info *swig_types[15];
-static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
+#define SWIGTYPE_p_logitmcstate swig_types[13]
+#define SWIGTYPE_p_logitmodel swig_types[14]
+#define SWIGTYPE_p_lrreport swig_types[15]
+#define SWIGTYPE_p_mnlreport swig_types[16]
+static swig_type_info *swig_types[18];
+static swig_module_info swig_module = {swig_types, 17, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -1813,11 +1816,11 @@ static VALUE mAlglib_ext;
 
 
 #include "ap.h"
-#include "linreg.h"
 #include "alglib_util.h"
 #include "iostream"
 
 
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -1913,11 +1916,11 @@ SWIG_From_int  (int value)
   return SWIG_From_long  (value);
 }
 
-SWIGINTERN int ap_template_1d_array_Sl_int_Sg____setitem__(ap::template_1d_array< int > *self,int i,int v){
+SWIGINTERN int ap_template_1d_array_Sl_int_Sg____setitem__(ap::template_1d_array< int > *self,int i,int v){ 
             return self->operator()(i)=v;
         }
-SWIGINTERN int ap_template_1d_array_Sl_int_Sg__size(ap::template_1d_array< int > *self){
-            return self->gethighbound()-self->getlowbound();
+SWIGINTERN int ap_template_1d_array_Sl_int_Sg__size(ap::template_1d_array< int > *self){ 
+            return self->gethighbound()-self->getlowbound()+1;
         }
 SWIGINTERN double ap_template_1d_array_Sl_double_Sc_true_Sg____getitem__(ap::template_1d_array< double,true > *self,int i){
             return self->operator()(i);
@@ -1954,11 +1957,11 @@ SWIG_AsVal_double (VALUE obj, double *val)
   return SWIG_TypeError;
 }
 
-SWIGINTERN double ap_template_1d_array_Sl_double_Sc_true_Sg____setitem__(ap::template_1d_array< double,true > *self,int i,double v){
+SWIGINTERN double ap_template_1d_array_Sl_double_Sc_true_Sg____setitem__(ap::template_1d_array< double,true > *self,int i,double v){ 
             return self->operator()(i)=v;
         }
-SWIGINTERN int ap_template_1d_array_Sl_double_Sc_true_Sg__size(ap::template_1d_array< double,true > *self){
-            return self->gethighbound()-self->getlowbound();
+SWIGINTERN int ap_template_1d_array_Sl_double_Sc_true_Sg__size(ap::template_1d_array< double,true > *self){ 
+            return self->gethighbound()-self->getlowbound()+1;
         }
 SWIGINTERN bool ap_template_1d_array_Sl_bool_Sg____getitem__(ap::template_1d_array< bool > *self,int i){
             return self->operator()(i);
@@ -1990,11 +1993,11 @@ SWIG_AsVal_bool (VALUE obj, bool *val)
   return SWIG_TypeError;
 }
 
-SWIGINTERN bool ap_template_1d_array_Sl_bool_Sg____setitem__(ap::template_1d_array< bool > *self,int i,bool v){
+SWIGINTERN bool ap_template_1d_array_Sl_bool_Sg____setitem__(ap::template_1d_array< bool > *self,int i,bool v){ 
             return self->operator()(i)=v;
         }
-SWIGINTERN int ap_template_1d_array_Sl_bool_Sg__size(ap::template_1d_array< bool > *self){
-            return self->gethighbound()-self->getlowbound();
+SWIGINTERN int ap_template_1d_array_Sl_bool_Sg__size(ap::template_1d_array< bool > *self){ 
+            return self->gethighbound()-self->getlowbound()+1;
         }
 SWIGINTERN double ap_template_2d_array_Sl_int_Sg____getitem__(ap::template_2d_array< int > *self,int x,int y){
         return self->operator()(x,y);
@@ -2008,6 +2011,66 @@ SWIGINTERN double ap_template_2d_array_Sl_double_Sc_true_Sg____getitem__(ap::tem
 SWIGINTERN void ap_template_2d_array_Sl_double_Sc_true_Sg____setitem__(ap::template_2d_array< double,true > *self,int x,int y,double val){
         self->operator()(x,y)=val;
     }
+
+#include "correlation.h"
+#include "ialglib.h"
+
+
+double wrap_spearmanrankcorrelation(const ap::real_1d_array& x,
+     const ap::real_1d_array& y,
+     int n) {
+     ap::real_1d_array x1,y1;
+     x1=x;
+     y1=y;
+     return spearmanrankcorrelation(x1,y1,n);
+     
+}
+
+
+#include "correlationtests.h"
+
+
+VALUE pearsoncorrelationsignificance(double r,
+     int n) {
+         VALUE ary;
+         double bt,lt,rt;
+         pearsoncorrelationsignificance(r, n, bt, lt, rt);
+         ary=rb_ary_new();
+         rb_ary_push(ary, rb_float_new(bt));
+         rb_ary_push(ary, rb_float_new(lt));
+         rb_ary_push(ary, rb_float_new(rt));
+         return ary;
+     }
+
+
+VALUE spearmanrankcorrelationsignificance(double r,
+     int n) {
+         VALUE ary;
+         double bt,lt,rt;
+         spearmanrankcorrelationsignificance(r, n, bt, lt, rt);
+         ary=rb_ary_new();
+         rb_ary_push(ary, rb_float_new(bt));
+         rb_ary_push(ary, rb_float_new(lt));
+         rb_ary_push(ary, rb_float_new(rt));
+         return ary;
+     }
+
+
+#include "linreg.h"
+
+
+#include "logit.h"
+
+
+VALUE wrap_mnlprocess(logitmodel& lm,
+     const ap::real_1d_array& x) {
+     ap::real_1d_array y;
+//     y.setlength(lm.w(3));
+     mnlprocess(lm,x,y);
+     // std::cout << "Saliendo";
+     return real1d_to_array(&y);
+}
+
 swig_class cInteger1dArray;
 
 SWIGINTERN VALUE
@@ -4595,6 +4658,197 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_real1d_to_array(int argc, VALUE *argv, VALUE self) {
+  ap::real_1d_array *arg1 = (ap::real_1d_array *) 0 ;
+  VALUE result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ap::real_1d_array *","real1d_to_array", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< ap::real_1d_array * >(argp1);
+  result = (VALUE)real1d_to_array(arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_array_to_real1d(int argc, VALUE *argv, VALUE self) {
+  VALUE arg1 = (VALUE) 0 ;
+  ap::real_1d_array *arg2 = (ap::real_1d_array *) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  arg1 = argv[0];
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "ap::real_1d_array *","array_to_real1d", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< ap::real_1d_array * >(argp2);
+  array_to_real1d(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_pearsoncorrelation(int argc, VALUE *argv, VALUE self) {
+  ap::real_1d_array *arg1 = 0 ;
+  ap::real_1d_array *arg2 = 0 ;
+  int arg3 ;
+  double result;
+  int val3 ;
+  int ecode3 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  {
+    arg1 = new ap::real_1d_array();
+    arg1->setlength(RARRAY_LEN(argv[0]));
+    for(long i=0;i<RARRAY_LEN(argv[0]);i++) {
+      arg1->operator()(i)=rb_num2dbl(RARRAY_PTR(argv[0])[i]);
+    }
+  }
+  {
+    arg2 = new ap::real_1d_array();
+    arg2->setlength(RARRAY_LEN(argv[1]));
+    for(long i=0;i<RARRAY_LEN(argv[1]);i++) {
+      arg2->operator()(i)=rb_num2dbl(RARRAY_PTR(argv[1])[i]);
+    }
+  }
+  ecode3 = SWIG_AsVal_int(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","pearsoncorrelation", 3, argv[2] ));
+  } 
+  arg3 = static_cast< int >(val3);
+  result = (double)pearsoncorrelation((ap::template_1d_array< double,true > const &)*arg1,(ap::template_1d_array< double,true > const &)*arg2,arg3);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_spearmanrankcorrelation(int argc, VALUE *argv, VALUE self) {
+  ap::real_1d_array *arg1 = 0 ;
+  ap::real_1d_array *arg2 = 0 ;
+  int arg3 ;
+  double result;
+  int val3 ;
+  int ecode3 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  {
+    arg1 = new ap::real_1d_array();
+    arg1->setlength(RARRAY_LEN(argv[0]));
+    for(long i=0;i<RARRAY_LEN(argv[0]);i++) {
+      arg1->operator()(i)=rb_num2dbl(RARRAY_PTR(argv[0])[i]);
+    }
+  }
+  {
+    arg2 = new ap::real_1d_array();
+    arg2->setlength(RARRAY_LEN(argv[1]));
+    for(long i=0;i<RARRAY_LEN(argv[1]);i++) {
+      arg2->operator()(i)=rb_num2dbl(RARRAY_PTR(argv[1])[i]);
+    }
+  }
+  ecode3 = SWIG_AsVal_int(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","wrap_spearmanrankcorrelation", 3, argv[2] ));
+  } 
+  arg3 = static_cast< int >(val3);
+  result = (double)wrap_spearmanrankcorrelation((ap::template_1d_array< double,true > const &)*arg1,(ap::template_1d_array< double,true > const &)*arg2,arg3);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_pearsoncorrelationsignificance(int argc, VALUE *argv, VALUE self) {
+  double arg1 ;
+  int arg2 ;
+  VALUE result;
+  double val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","pearsoncorrelationsignificance", 1, argv[0] ));
+  } 
+  arg1 = static_cast< double >(val1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pearsoncorrelationsignificance", 2, argv[1] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  result = (VALUE)pearsoncorrelationsignificance(arg1,arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_spearmanrankcorrelationsignificance(int argc, VALUE *argv, VALUE self) {
+  double arg1 ;
+  int arg2 ;
+  VALUE result;
+  double val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","spearmanrankcorrelationsignificance", 1, argv[0] ));
+  } 
+  arg1 = static_cast< double >(val1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","spearmanrankcorrelationsignificance", 2, argv[1] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  result = (VALUE)spearmanrankcorrelationsignificance(arg1,arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 swig_class cLinearModel;
 
 SWIGINTERN VALUE
@@ -5646,55 +5900,2054 @@ fail:
 }
 
 
+swig_class cLogitModel;
+
 SWIGINTERN VALUE
-_wrap_real1d_to_array(int argc, VALUE *argv, VALUE self) {
-  ap::real_1d_array *arg1 = (ap::real_1d_array *) 0 ;
-  VALUE result;
+_wrap_LogitModel_w_set(int argc, VALUE *argv, VALUE self) {
+  logitmodel *arg1 = (logitmodel *) 0 ;
+  ap::real_1d_array *arg2 = (ap::real_1d_array *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  VALUE vresult = Qnil;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmodel, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ap::real_1d_array *","real1d_to_array", 1, argv[0] )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmodel *","w", 1, self )); 
   }
-  arg1 = reinterpret_cast< ap::real_1d_array * >(argp1);
-  result = (VALUE)real1d_to_array(arg1);
-  vresult = result;
-  return vresult;
+  arg1 = reinterpret_cast< logitmodel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "ap::real_1d_array *","w", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< ap::real_1d_array * >(argp2);
+  if (arg1) (arg1)->w = *arg2;
+  
+  return Qnil;
 fail:
   return Qnil;
 }
 
 
+SWIGINTERN VALUE
+_wrap_LogitModel_w_get(int argc, VALUE *argv, VALUE self) {
+  logitmodel *arg1 = (logitmodel *) 0 ;
+  ap::real_1d_array *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmodel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmodel *","w", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmodel * >(argp1);
+  result = (ap::real_1d_array *)& ((arg1)->w);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
 
-/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
-static swig_type_info _swigt__p_ap__template_1d_arrayT_bool_false_t = {"_p_ap__template_1d_arrayT_bool_false_t", "ap::boolean_1d_array *|ap::template_1d_array< bool > *|ap::template_1d_array< bool,false > *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ap__template_1d_arrayT_complex_false_t = {"_p_ap__template_1d_arrayT_complex_false_t", "ap::complex_1d_array *|ap::template_1d_array< complex,false > *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ap__template_1d_arrayT_double_true_t = {"_p_ap__template_1d_arrayT_double_true_t", "ap::real_1d_array *|ap::template_1d_array< double,true > *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ap__template_1d_arrayT_int_false_t = {"_p_ap__template_1d_arrayT_int_false_t", "ap::integer_1d_array *|ap::template_1d_array< int > *|ap::template_1d_array< int,false > *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ap__template_2d_arrayT_bool_false_t = {"_p_ap__template_2d_arrayT_bool_false_t", "ap::boolean_2d_array *|ap::template_2d_array< bool,false > *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ap__template_2d_arrayT_complex_false_t = {"_p_ap__template_2d_arrayT_complex_false_t", "ap::complex_2d_array *|ap::template_2d_array< complex,false > *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ap__template_2d_arrayT_double_true_t = {"_p_ap__template_2d_arrayT_double_true_t", "ap::real_2d_array *|ap::template_2d_array< double,true > *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_ap__template_2d_arrayT_int_false_t = {"_p_ap__template_2d_arrayT_int_false_t", "ap::integer_2d_array *|ap::template_2d_array< int > *|ap::template_2d_array< int,false > *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_linearmodel = {"_p_linearmodel", "linearmodel *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_lrreport = {"_p_lrreport", "lrreport *", 0, 0, (void*)0, 0};
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+SWIGINTERN VALUE
+_wrap_LogitModel_allocate(VALUE self) {
+#else
+  SWIGINTERN VALUE
+  _wrap_LogitModel_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+    
+    
+    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_logitmodel);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_obj_call_init(vresult, argc, argv);
+#endif
+    return vresult;
+  }
+  
 
-static swig_type_info *swig_type_initial[] = {
-  &_swigt__p_ap__template_1d_arrayT_bool_false_t,
-  &_swigt__p_ap__template_1d_arrayT_complex_false_t,
-  &_swigt__p_ap__template_1d_arrayT_double_true_t,
-  &_swigt__p_ap__template_1d_arrayT_int_false_t,
-  &_swigt__p_ap__template_2d_arrayT_bool_false_t,
-  &_swigt__p_ap__template_2d_arrayT_complex_false_t,
+SWIGINTERN VALUE
+_wrap_new_LogitModel(int argc, VALUE *argv, VALUE self) {
+  logitmodel *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (logitmodel *)new logitmodel();DATA_PTR(self) = result;
+  
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_logitmodel(logitmodel *arg1) {
+    delete arg1;
+}
+
+swig_class cLogitMcState;
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_brackt_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  bool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","brackt", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","brackt", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  if (arg1) (arg1)->brackt = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_brackt_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","brackt", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (bool) ((arg1)->brackt);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_stage1_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  bool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stage1", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","stage1", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  if (arg1) (arg1)->stage1 = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_stage1_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stage1", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (bool) ((arg1)->stage1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_infoc_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","infoc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","infoc", 2, argv[0] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  if (arg1) (arg1)->infoc = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_infoc_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","infoc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (int) ((arg1)->infoc);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dg_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dg", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dg", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->dg = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dg_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dg", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->dg);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dgm_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgm", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dgm", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->dgm = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dgm_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgm", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->dgm);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dginit_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dginit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dginit", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->dginit = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dginit_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dginit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->dginit);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dgtest_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgtest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dgtest", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->dgtest = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dgtest_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgtest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->dgtest);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dgx_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgx", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dgx", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->dgx = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dgx_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgx", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->dgx);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dgxm_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgxm", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dgxm", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->dgxm = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dgxm_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgxm", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->dgxm);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dgy_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dgy", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->dgy = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dgy_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->dgy);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dgym_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgym", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dgym", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->dgym = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_dgym_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgym", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->dgym);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_finit_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","finit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","finit", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->finit = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_finit_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","finit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->finit);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_ftest1_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","ftest1", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","ftest1", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->ftest1 = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_ftest1_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","ftest1", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->ftest1);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_fm_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fm", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","fm", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->fm = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_fm_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fm", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->fm);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_fx_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fx", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","fx", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->fx = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_fx_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fx", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->fx);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_fxm_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fxm", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","fxm", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->fxm = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_fxm_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fxm", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->fxm);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_fy_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","fy", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->fy = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_fy_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->fy);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_fym_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fym", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","fym", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->fym = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_fym_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fym", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->fym);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_stx_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stx", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","stx", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->stx = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_stx_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stx", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->stx);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_sty_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","sty", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","sty", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->sty = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_sty_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","sty", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->sty);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_stmin_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stmin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","stmin", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->stmin = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_stmin_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stmin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->stmin);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_stmax_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stmax", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","stmax", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->stmax = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_stmax_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stmax", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->stmax);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_width_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","width", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","width", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->width = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_width_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","width", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->width);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_width1_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","width1", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","width1", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->width1 = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_width1_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","width1", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->width1);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_xtrapf_set(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","xtrapf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","xtrapf", 2, argv[0] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (arg1) (arg1)->xtrapf = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_LogitMcState_xtrapf_get(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *arg1 = (logitmcstate *) 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","xtrapf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< logitmcstate * >(argp1);
+  result = (double) ((arg1)->xtrapf);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+SWIGINTERN VALUE
+_wrap_LogitMcState_allocate(VALUE self) {
+#else
+  SWIGINTERN VALUE
+  _wrap_LogitMcState_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+    
+    
+    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_logitmcstate);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_obj_call_init(vresult, argc, argv);
+#endif
+    return vresult;
+  }
+  
+
+SWIGINTERN VALUE
+_wrap_new_LogitMcState(int argc, VALUE *argv, VALUE self) {
+  logitmcstate *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (logitmcstate *)new logitmcstate();DATA_PTR(self) = result;
+  
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_logitmcstate(logitmcstate *arg1) {
+    delete arg1;
+}
+
+swig_class cMNLReport;
+
+SWIGINTERN VALUE
+_wrap_MNLReport_ngrad_set(int argc, VALUE *argv, VALUE self) {
+  mnlreport *arg1 = (mnlreport *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mnlreport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mnlreport *","ngrad", 1, self )); 
+  }
+  arg1 = reinterpret_cast< mnlreport * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","ngrad", 2, argv[0] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  if (arg1) (arg1)->ngrad = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MNLReport_ngrad_get(int argc, VALUE *argv, VALUE self) {
+  mnlreport *arg1 = (mnlreport *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mnlreport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mnlreport *","ngrad", 1, self )); 
+  }
+  arg1 = reinterpret_cast< mnlreport * >(argp1);
+  result = (int) ((arg1)->ngrad);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MNLReport_nhess_set(int argc, VALUE *argv, VALUE self) {
+  mnlreport *arg1 = (mnlreport *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mnlreport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mnlreport *","nhess", 1, self )); 
+  }
+  arg1 = reinterpret_cast< mnlreport * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","nhess", 2, argv[0] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  if (arg1) (arg1)->nhess = arg2;
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MNLReport_nhess_get(int argc, VALUE *argv, VALUE self) {
+  mnlreport *arg1 = (mnlreport *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mnlreport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mnlreport *","nhess", 1, self )); 
+  }
+  arg1 = reinterpret_cast< mnlreport * >(argp1);
+  result = (int) ((arg1)->nhess);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+SWIGINTERN VALUE
+_wrap_MNLReport_allocate(VALUE self) {
+#else
+  SWIGINTERN VALUE
+  _wrap_MNLReport_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+    
+    
+    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_mnlreport);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_obj_call_init(vresult, argc, argv);
+#endif
+    return vresult;
+  }
+  
+
+SWIGINTERN VALUE
+_wrap_new_MNLReport(int argc, VALUE *argv, VALUE self) {
+  mnlreport *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (mnlreport *)new mnlreport();DATA_PTR(self) = result;
+  
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_mnlreport(mnlreport *arg1) {
+    delete arg1;
+}
+
+SWIGINTERN VALUE
+_wrap_mnltrainh(int argc, VALUE *argv, VALUE self) {
+  ap::real_2d_array *arg1 = 0 ;
+  int arg2 ;
+  int arg3 ;
+  int arg4 ;
+  int *arg5 = 0 ;
+  logitmodel *arg6 = 0 ;
+  mnlreport *arg7 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
+  int temp5 ;
+  int res5 = SWIG_TMPOBJ ;
+  void *argp6 = 0 ;
+  int res6 = 0 ;
+  void *argp7 = 0 ;
+  int res7 = 0 ;
+  VALUE vresult = Qnil;
+  
+  arg5 = &temp5;
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_ap__template_2d_arrayT_double_true_t,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ap::real_2d_array const &","mnltrainh", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::real_2d_array const &","mnltrainh", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< ap::real_2d_array * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","mnltrainh", 2, argv[1] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  ecode3 = SWIG_AsVal_int(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","mnltrainh", 3, argv[2] ));
+  } 
+  arg3 = static_cast< int >(val3);
+  ecode4 = SWIG_AsVal_int(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","mnltrainh", 4, argv[3] ));
+  } 
+  arg4 = static_cast< int >(val4);
+  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_logitmodel,  0 );
+  if (!SWIG_IsOK(res6)) {
+    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "logitmodel &","mnltrainh", 6, argv[4] )); 
+  }
+  if (!argp6) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel &","mnltrainh", 6, argv[4])); 
+  }
+  arg6 = reinterpret_cast< logitmodel * >(argp6);
+  res7 = SWIG_ConvertPtr(argv[5], &argp7, SWIGTYPE_p_mnlreport,  0 );
+  if (!SWIG_IsOK(res7)) {
+    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "mnlreport &","mnltrainh", 7, argv[5] )); 
+  }
+  if (!argp7) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "mnlreport &","mnltrainh", 7, argv[5])); 
+  }
+  arg7 = reinterpret_cast< mnlreport * >(argp7);
+  mnltrainh((ap::template_2d_array< double,true > const &)*arg1,arg2,arg3,arg4,*arg5,*arg6,*arg7);
+  if (SWIG_IsTmpObj(res5)) {
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg5)));
+  } else {
+    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
+    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_mnlprocess(int argc, VALUE *argv, VALUE self) {
+  logitmodel *arg1 = 0 ;
+  ap::real_1d_array *arg2 = 0 ;
+  VALUE result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_logitmodel,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmodel &","wrap_mnlprocess", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel &","wrap_mnlprocess", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< logitmodel * >(argp1);
+  {
+    arg2 = new ap::real_1d_array();
+    arg2->setlength(RARRAY_LEN(argv[1]));
+    for(long i=0;i<RARRAY_LEN(argv[1]);i++) {
+      arg2->operator()(i)=rb_num2dbl(RARRAY_PTR(argv[1])[i]);
+    }
+  }
+  result = (VALUE)wrap_mnlprocess(*arg1,(ap::template_1d_array< double,true > const &)*arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_mnlunpack(int argc, VALUE *argv, VALUE self) {
+  logitmodel *arg1 = 0 ;
+  ap::real_2d_array *arg2 = 0 ;
+  int *arg3 = 0 ;
+  int *arg4 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int temp3 ;
+  int res3 = 0 ;
+  int temp4 ;
+  int res4 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_logitmodel,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmodel const &","mnlunpack", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel const &","mnlunpack", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< logitmodel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_ap__template_2d_arrayT_double_true_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "ap::real_2d_array &","mnlunpack", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::real_2d_array &","mnlunpack", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< ap::real_2d_array * >(argp2);
+  if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
+    int val; 
+    int ecode = SWIG_AsVal_int(argv[2], &val);
+    if (!SWIG_IsOK(ecode)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "int","mnlunpack", 3, argv[2] ));
+    }
+    temp3 = static_cast< int >(val);
+    arg3 = &temp3;
+    res3 = SWIG_AddTmpMask(ecode);
+  }
+  if (!(SWIG_IsOK((res4 = SWIG_ConvertPtr(argv[3],SWIG_as_voidptrptr(&arg4),SWIGTYPE_p_int,0))))) {
+    int val; 
+    int ecode = SWIG_AsVal_int(argv[3], &val);
+    if (!SWIG_IsOK(ecode)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "int","mnlunpack", 4, argv[3] ));
+    }
+    temp4 = static_cast< int >(val);
+    arg4 = &temp4;
+    res4 = SWIG_AddTmpMask(ecode);
+  }
+  mnlunpack((logitmodel const &)*arg1,*arg2,*arg3,*arg4);
+  if (SWIG_IsNewObj(res3)) delete arg3;
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return Qnil;
+fail:
+  if (SWIG_IsNewObj(res3)) delete arg3;
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_mnlpack(int argc, VALUE *argv, VALUE self) {
+  ap::real_2d_array *arg1 = 0 ;
+  int arg2 ;
+  int arg3 ;
+  logitmodel *arg4 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_ap__template_2d_arrayT_double_true_t,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ap::real_2d_array const &","mnlpack", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::real_2d_array const &","mnlpack", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< ap::real_2d_array * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","mnlpack", 2, argv[1] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  ecode3 = SWIG_AsVal_int(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","mnlpack", 3, argv[2] ));
+  } 
+  arg3 = static_cast< int >(val3);
+  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_logitmodel,  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "logitmodel &","mnlpack", 4, argv[3] )); 
+  }
+  if (!argp4) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel &","mnlpack", 4, argv[3])); 
+  }
+  arg4 = reinterpret_cast< logitmodel * >(argp4);
+  mnlpack((ap::template_2d_array< double,true > const &)*arg1,arg2,arg3,*arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_mnlserialize(int argc, VALUE *argv, VALUE self) {
+  logitmodel *arg1 = 0 ;
+  ap::real_1d_array *arg2 = 0 ;
+  int *arg3 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_logitmodel,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmodel const &","mnlserialize", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel const &","mnlserialize", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< logitmodel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_ap__template_1d_arrayT_double_true_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "ap::real_1d_array &","mnlserialize", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::real_1d_array &","mnlserialize", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< ap::real_1d_array * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_int,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int &","mnlserialize", 3, argv[2] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int &","mnlserialize", 3, argv[2])); 
+  }
+  arg3 = reinterpret_cast< int * >(argp3);
+  mnlserialize((logitmodel const &)*arg1,*arg2,*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_mnlcopy(int argc, VALUE *argv, VALUE self) {
+  logitmodel *arg1 = 0 ;
+  logitmodel *arg2 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_logitmodel,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmodel const &","mnlcopy", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel const &","mnlcopy", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< logitmodel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_logitmodel,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "logitmodel &","mnlcopy", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel &","mnlcopy", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< logitmodel * >(argp2);
+  mnlcopy((logitmodel const &)*arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_mnlunserialize(int argc, VALUE *argv, VALUE self) {
+  ap::real_1d_array *arg1 = 0 ;
+  logitmodel *arg2 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  {
+    arg1 = new ap::real_1d_array();
+    arg1->setlength(RARRAY_LEN(argv[0]));
+    for(long i=0;i<RARRAY_LEN(argv[0]);i++) {
+      arg1->operator()(i)=rb_num2dbl(RARRAY_PTR(argv[0])[i]);
+    }
+  }
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_logitmodel,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "logitmodel &","mnlunserialize", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel &","mnlunserialize", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< logitmodel * >(argp2);
+  mnlunserialize((ap::template_1d_array< double,true > const &)*arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_mnlavgce(int argc, VALUE *argv, VALUE self) {
+  logitmodel *arg1 = 0 ;
+  ap::real_2d_array *arg2 = 0 ;
+  int arg3 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_logitmodel,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmodel &","mnlavgce", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel &","mnlavgce", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< logitmodel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_ap__template_2d_arrayT_double_true_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "ap::real_2d_array const &","mnlavgce", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::real_2d_array const &","mnlavgce", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< ap::real_2d_array * >(argp2);
+  ecode3 = SWIG_AsVal_int(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","mnlavgce", 3, argv[2] ));
+  } 
+  arg3 = static_cast< int >(val3);
+  result = (double)mnlavgce(*arg1,(ap::template_2d_array< double,true > const &)*arg2,arg3);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static swig_type_info _swigt__p_ap__template_1d_arrayT_bool_false_t = {"_p_ap__template_1d_arrayT_bool_false_t", "ap::boolean_1d_array *|ap::template_1d_array< bool > *|ap::template_1d_array< bool,false > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ap__template_1d_arrayT_complex_false_t = {"_p_ap__template_1d_arrayT_complex_false_t", "ap::complex_1d_array *|ap::template_1d_array< complex,false > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ap__template_1d_arrayT_double_true_t = {"_p_ap__template_1d_arrayT_double_true_t", "ap::real_1d_array *|ap::template_1d_array< double,true > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ap__template_1d_arrayT_int_false_t = {"_p_ap__template_1d_arrayT_int_false_t", "ap::integer_1d_array *|ap::template_1d_array< int > *|ap::template_1d_array< int,false > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ap__template_2d_arrayT_bool_false_t = {"_p_ap__template_2d_arrayT_bool_false_t", "ap::boolean_2d_array *|ap::template_2d_array< bool,false > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ap__template_2d_arrayT_complex_false_t = {"_p_ap__template_2d_arrayT_complex_false_t", "ap::complex_2d_array *|ap::template_2d_array< complex,false > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ap__template_2d_arrayT_double_true_t = {"_p_ap__template_2d_arrayT_double_true_t", "ap::real_2d_array *|ap::template_2d_array< double,true > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ap__template_2d_arrayT_int_false_t = {"_p_ap__template_2d_arrayT_int_false_t", "ap::integer_2d_array *|ap::template_2d_array< int > *|ap::template_2d_array< int,false > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_linearmodel = {"_p_linearmodel", "linearmodel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_logitmcstate = {"_p_logitmcstate", "logitmcstate *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_logitmodel = {"_p_logitmodel", "logitmodel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_lrreport = {"_p_lrreport", "lrreport *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_mnlreport = {"_p_mnlreport", "mnlreport *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_ap__template_1d_arrayT_bool_false_t,
+  &_swigt__p_ap__template_1d_arrayT_complex_false_t,
+  &_swigt__p_ap__template_1d_arrayT_double_true_t,
+  &_swigt__p_ap__template_1d_arrayT_int_false_t,
+  &_swigt__p_ap__template_2d_arrayT_bool_false_t,
+  &_swigt__p_ap__template_2d_arrayT_complex_false_t,
   &_swigt__p_ap__template_2d_arrayT_double_true_t,
   &_swigt__p_ap__template_2d_arrayT_int_false_t,
   &_swigt__p_bool,
@@ -5702,7 +7955,10 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_double,
   &_swigt__p_int,
   &_swigt__p_linearmodel,
+  &_swigt__p_logitmcstate,
+  &_swigt__p_logitmodel,
   &_swigt__p_lrreport,
+  &_swigt__p_mnlreport,
 };
 
 static swig_cast_info _swigc__p_ap__template_1d_arrayT_bool_false_t[] = {  {&_swigt__p_ap__template_1d_arrayT_bool_false_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -5718,7 +7974,10 @@ static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0,
 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_linearmodel[] = {  {&_swigt__p_linearmodel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_logitmcstate[] = {  {&_swigt__p_logitmcstate, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_logitmodel[] = {  {&_swigt__p_logitmodel, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_lrreport[] = {  {&_swigt__p_lrreport, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_mnlreport[] = {  {&_swigt__p_mnlreport, 0, 0, 0},{0, 0, 0, 0}};
 
 static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_ap__template_1d_arrayT_bool_false_t,
@@ -5734,7 +7993,10 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_double,
   _swigc__p_int,
   _swigc__p_linearmodel,
+  _swigc__p_logitmcstate,
+  _swigc__p_logitmodel,
   _swigc__p_lrreport,
+  _swigc__p_mnlreport,
 };
 
 
@@ -6078,6 +8340,12 @@ SWIGEXPORT void Init_alglib_ext(void) {
   cReal2dArray.mark = 0;
   cReal2dArray.destroy = (void (*)(void *)) free_ap_template_2d_array_Sl_double_Sc_true_Sg_;
   cReal2dArray.trackObjects = 0;
+  rb_define_module_function(mAlglib_ext, "real1d_to_array", VALUEFUNC(_wrap_real1d_to_array), -1);
+  rb_define_module_function(mAlglib_ext, "array_to_real1d", VALUEFUNC(_wrap_array_to_real1d), -1);
+  rb_define_module_function(mAlglib_ext, "pearsoncorrelation", VALUEFUNC(_wrap_pearsoncorrelation), -1);
+  rb_define_module_function(mAlglib_ext, "spearmanrankcorrelation", VALUEFUNC(_wrap_spearmanrankcorrelation), -1);
+  rb_define_module_function(mAlglib_ext, "pearsoncorrelationsignificance", VALUEFUNC(_wrap_pearsoncorrelationsignificance), -1);
+  rb_define_module_function(mAlglib_ext, "spearmanrankcorrelationsignificance", VALUEFUNC(_wrap_spearmanrankcorrelationsignificance), -1);
   
   cLinearModel.klass = rb_define_class_under(mAlglib_ext, "LinearModel", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_linearmodel, (void *) &cLinearModel);
@@ -6121,6 +8389,93 @@ SWIGEXPORT void Init_alglib_ext(void) {
   rb_define_module_function(mAlglib_ext, "lrunpack", VALUEFUNC(_wrap_lrunpack), -1);
   rb_define_module_function(mAlglib_ext, "lrpack", VALUEFUNC(_wrap_lrpack), -1);
   rb_define_module_function(mAlglib_ext, "lrprocess", VALUEFUNC(_wrap_lrprocess), -1);
-  rb_define_module_function(mAlglib_ext, "real1d_to_array", VALUEFUNC(_wrap_real1d_to_array), -1);
+  
+  cLogitModel.klass = rb_define_class_under(mAlglib_ext, "LogitModel", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_logitmodel, (void *) &cLogitModel);
+  rb_define_alloc_func(cLogitModel.klass, _wrap_LogitModel_allocate);
+  rb_define_method(cLogitModel.klass, "initialize", VALUEFUNC(_wrap_new_LogitModel), -1);
+  rb_define_method(cLogitModel.klass, "w=", VALUEFUNC(_wrap_LogitModel_w_set), -1);
+  rb_define_method(cLogitModel.klass, "w", VALUEFUNC(_wrap_LogitModel_w_get), -1);
+  cLogitModel.mark = 0;
+  cLogitModel.destroy = (void (*)(void *)) free_logitmodel;
+  cLogitModel.trackObjects = 0;
+  
+  cLogitMcState.klass = rb_define_class_under(mAlglib_ext, "LogitMcState", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_logitmcstate, (void *) &cLogitMcState);
+  rb_define_alloc_func(cLogitMcState.klass, _wrap_LogitMcState_allocate);
+  rb_define_method(cLogitMcState.klass, "initialize", VALUEFUNC(_wrap_new_LogitMcState), -1);
+  rb_define_method(cLogitMcState.klass, "brackt=", VALUEFUNC(_wrap_LogitMcState_brackt_set), -1);
+  rb_define_method(cLogitMcState.klass, "brackt", VALUEFUNC(_wrap_LogitMcState_brackt_get), -1);
+  rb_define_method(cLogitMcState.klass, "stage1=", VALUEFUNC(_wrap_LogitMcState_stage1_set), -1);
+  rb_define_method(cLogitMcState.klass, "stage1", VALUEFUNC(_wrap_LogitMcState_stage1_get), -1);
+  rb_define_method(cLogitMcState.klass, "infoc=", VALUEFUNC(_wrap_LogitMcState_infoc_set), -1);
+  rb_define_method(cLogitMcState.klass, "infoc", VALUEFUNC(_wrap_LogitMcState_infoc_get), -1);
+  rb_define_method(cLogitMcState.klass, "dg=", VALUEFUNC(_wrap_LogitMcState_dg_set), -1);
+  rb_define_method(cLogitMcState.klass, "dg", VALUEFUNC(_wrap_LogitMcState_dg_get), -1);
+  rb_define_method(cLogitMcState.klass, "dgm=", VALUEFUNC(_wrap_LogitMcState_dgm_set), -1);
+  rb_define_method(cLogitMcState.klass, "dgm", VALUEFUNC(_wrap_LogitMcState_dgm_get), -1);
+  rb_define_method(cLogitMcState.klass, "dginit=", VALUEFUNC(_wrap_LogitMcState_dginit_set), -1);
+  rb_define_method(cLogitMcState.klass, "dginit", VALUEFUNC(_wrap_LogitMcState_dginit_get), -1);
+  rb_define_method(cLogitMcState.klass, "dgtest=", VALUEFUNC(_wrap_LogitMcState_dgtest_set), -1);
+  rb_define_method(cLogitMcState.klass, "dgtest", VALUEFUNC(_wrap_LogitMcState_dgtest_get), -1);
+  rb_define_method(cLogitMcState.klass, "dgx=", VALUEFUNC(_wrap_LogitMcState_dgx_set), -1);
+  rb_define_method(cLogitMcState.klass, "dgx", VALUEFUNC(_wrap_LogitMcState_dgx_get), -1);
+  rb_define_method(cLogitMcState.klass, "dgxm=", VALUEFUNC(_wrap_LogitMcState_dgxm_set), -1);
+  rb_define_method(cLogitMcState.klass, "dgxm", VALUEFUNC(_wrap_LogitMcState_dgxm_get), -1);
+  rb_define_method(cLogitMcState.klass, "dgy=", VALUEFUNC(_wrap_LogitMcState_dgy_set), -1);
+  rb_define_method(cLogitMcState.klass, "dgy", VALUEFUNC(_wrap_LogitMcState_dgy_get), -1);
+  rb_define_method(cLogitMcState.klass, "dgym=", VALUEFUNC(_wrap_LogitMcState_dgym_set), -1);
+  rb_define_method(cLogitMcState.klass, "dgym", VALUEFUNC(_wrap_LogitMcState_dgym_get), -1);
+  rb_define_method(cLogitMcState.klass, "finit=", VALUEFUNC(_wrap_LogitMcState_finit_set), -1);
+  rb_define_method(cLogitMcState.klass, "finit", VALUEFUNC(_wrap_LogitMcState_finit_get), -1);
+  rb_define_method(cLogitMcState.klass, "ftest1=", VALUEFUNC(_wrap_LogitMcState_ftest1_set), -1);
+  rb_define_method(cLogitMcState.klass, "ftest1", VALUEFUNC(_wrap_LogitMcState_ftest1_get), -1);
+  rb_define_method(cLogitMcState.klass, "fm=", VALUEFUNC(_wrap_LogitMcState_fm_set), -1);
+  rb_define_method(cLogitMcState.klass, "fm", VALUEFUNC(_wrap_LogitMcState_fm_get), -1);
+  rb_define_method(cLogitMcState.klass, "fx=", VALUEFUNC(_wrap_LogitMcState_fx_set), -1);
+  rb_define_method(cLogitMcState.klass, "fx", VALUEFUNC(_wrap_LogitMcState_fx_get), -1);
+  rb_define_method(cLogitMcState.klass, "fxm=", VALUEFUNC(_wrap_LogitMcState_fxm_set), -1);
+  rb_define_method(cLogitMcState.klass, "fxm", VALUEFUNC(_wrap_LogitMcState_fxm_get), -1);
+  rb_define_method(cLogitMcState.klass, "fy=", VALUEFUNC(_wrap_LogitMcState_fy_set), -1);
+  rb_define_method(cLogitMcState.klass, "fy", VALUEFUNC(_wrap_LogitMcState_fy_get), -1);
+  rb_define_method(cLogitMcState.klass, "fym=", VALUEFUNC(_wrap_LogitMcState_fym_set), -1);
+  rb_define_method(cLogitMcState.klass, "fym", VALUEFUNC(_wrap_LogitMcState_fym_get), -1);
+  rb_define_method(cLogitMcState.klass, "stx=", VALUEFUNC(_wrap_LogitMcState_stx_set), -1);
+  rb_define_method(cLogitMcState.klass, "stx", VALUEFUNC(_wrap_LogitMcState_stx_get), -1);
+  rb_define_method(cLogitMcState.klass, "sty=", VALUEFUNC(_wrap_LogitMcState_sty_set), -1);
+  rb_define_method(cLogitMcState.klass, "sty", VALUEFUNC(_wrap_LogitMcState_sty_get), -1);
+  rb_define_method(cLogitMcState.klass, "stmin=", VALUEFUNC(_wrap_LogitMcState_stmin_set), -1);
+  rb_define_method(cLogitMcState.klass, "stmin", VALUEFUNC(_wrap_LogitMcState_stmin_get), -1);
+  rb_define_method(cLogitMcState.klass, "stmax=", VALUEFUNC(_wrap_LogitMcState_stmax_set), -1);
+  rb_define_method(cLogitMcState.klass, "stmax", VALUEFUNC(_wrap_LogitMcState_stmax_get), -1);
+  rb_define_method(cLogitMcState.klass, "width=", VALUEFUNC(_wrap_LogitMcState_width_set), -1);
+  rb_define_method(cLogitMcState.klass, "width", VALUEFUNC(_wrap_LogitMcState_width_get), -1);
+  rb_define_method(cLogitMcState.klass, "width1=", VALUEFUNC(_wrap_LogitMcState_width1_set), -1);
+  rb_define_method(cLogitMcState.klass, "width1", VALUEFUNC(_wrap_LogitMcState_width1_get), -1);
+  rb_define_method(cLogitMcState.klass, "xtrapf=", VALUEFUNC(_wrap_LogitMcState_xtrapf_set), -1);
+  rb_define_method(cLogitMcState.klass, "xtrapf", VALUEFUNC(_wrap_LogitMcState_xtrapf_get), -1);
+  cLogitMcState.mark = 0;
+  cLogitMcState.destroy = (void (*)(void *)) free_logitmcstate;
+  cLogitMcState.trackObjects = 0;
+  
+  cMNLReport.klass = rb_define_class_under(mAlglib_ext, "MNLReport", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_mnlreport, (void *) &cMNLReport);
+  rb_define_alloc_func(cMNLReport.klass, _wrap_MNLReport_allocate);
+  rb_define_method(cMNLReport.klass, "initialize", VALUEFUNC(_wrap_new_MNLReport), -1);
+  rb_define_method(cMNLReport.klass, "ngrad=", VALUEFUNC(_wrap_MNLReport_ngrad_set), -1);
+  rb_define_method(cMNLReport.klass, "ngrad", VALUEFUNC(_wrap_MNLReport_ngrad_get), -1);
+  rb_define_method(cMNLReport.klass, "nhess=", VALUEFUNC(_wrap_MNLReport_nhess_set), -1);
+  rb_define_method(cMNLReport.klass, "nhess", VALUEFUNC(_wrap_MNLReport_nhess_get), -1);
+  cMNLReport.mark = 0;
+  cMNLReport.destroy = (void (*)(void *)) free_mnlreport;
+  cMNLReport.trackObjects = 0;
+  rb_define_module_function(mAlglib_ext, "mnltrainh", VALUEFUNC(_wrap_mnltrainh), -1);
+  rb_define_module_function(mAlglib_ext, "mnlprocess", VALUEFUNC(_wrap_mnlprocess), -1);
+  rb_define_module_function(mAlglib_ext, "mnlunpack", VALUEFUNC(_wrap_mnlunpack), -1);
+  rb_define_module_function(mAlglib_ext, "mnlpack", VALUEFUNC(_wrap_mnlpack), -1);
+  rb_define_module_function(mAlglib_ext, "mnlserialize", VALUEFUNC(_wrap_mnlserialize), -1);
+  rb_define_module_function(mAlglib_ext, "mnlcopy", VALUEFUNC(_wrap_mnlcopy), -1);
+  rb_define_module_function(mAlglib_ext, "mnlunserialize", VALUEFUNC(_wrap_mnlunserialize), -1);
+  rb_define_module_function(mAlglib_ext, "mnlavgce", VALUEFUNC(_wrap_mnlavgce), -1);
 }