alglib 0.1.2 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,7 +1,3 @@
1
- === 1.0.1 / 2009-08-20
2
- * Logit class. Implemented Logit#process and Logit#unpack.
3
- * Correlation. Implemented Alglib.pearson_correlation and Alglib.spearman_correlation
4
-
5
1
  === 1.0.0 / 2009-07-28
6
2
 
7
3
  * First version of Alglib. Only Multiple Regression Implemented
@@ -238,16 +238,6 @@ ext/alglib/variancetests.cpp
238
238
  ext/alglib/variancetests.h
239
239
  ext/alglib/wsr.cpp
240
240
  ext/alglib/wsr.h
241
- ext/ap.i
242
- ext/correlation.i
243
241
  ext/extconf.rb
244
- ext/logit.i
245
242
  lib/alglib.rb
246
- lib/alglib/correlation.rb
247
- lib/alglib/linearregression.rb
248
- lib/alglib/logit.rb
249
243
  test/test_alglib.rb
250
- test/test_correlation.rb
251
- test/test_correlationtest.rb
252
- test/test_linreg.rb
253
- test/test_logit.rb
data/README.txt CHANGED
@@ -9,7 +9,7 @@ ALGLIB - is a multilingual collection of algorithms designed to solve problems i
9
9
 
10
10
  == FEATURES/PROBLEMS:
11
11
 
12
- * Only Multiple regression, Logit Regression and Correlation implemented
12
+ * Only Multiple regression Implemented
13
13
 
14
14
 
15
15
  == SYNOPSIS:
data/Rakefile CHANGED
@@ -1,36 +1,25 @@
1
- #!/usr/bin/ruby
2
1
  # -*- ruby -*-
3
- MAKEFILE="ext/Makefile.#{RUBY_VERSION}"
4
- BASEDIR=File.dirname(__FILE__)
2
+
5
3
  require 'rubygems'
6
4
  require 'hoe'
7
- require 'fileutils'
5
+
8
6
  task :default => [:compile]
9
7
  task :compile => ["ext/alglib_ext.so"]
10
- task :clean do
11
- FileList.new("ext/**/*.o","ext/**/*.so","ext/Makefile.*").each {|file|
12
- FileUtils.rm(file)
13
- }
14
- end
15
8
 
16
- file MAKEFILE => "ext/extconf.rb" do |t|
17
- Dir.chdir("#{BASEDIR}/ext")
18
- ruby %{extconf.rb}
19
- Dir.chdir("#{BASEDIR}")
9
+ file "ext/Makefile" => "ext/extconf.rb" do |t|
10
+ system %(cd ext && ruby extconf.rb)
20
11
  end
21
12
 
22
- file "ext/alglib_ext.so" => Dir.glob("ext/*.i")+[MAKEFILE, "ext/alglib/alglib_util.cpp", "ext/alglib/alglib_util.h"] do |t|
23
- Dir.chdir "#{BASEDIR}/ext"
24
- ruby %{-S rake}
25
- Dir.chdir BASEDIR
13
+ file "ext/alglib_ext.so" => ["ext/Makefile","ext/alglib.i"] do |t|
14
+ system %(cd ext && rake)
15
+
26
16
  end
27
- require File.dirname(__FILE__)+'/lib/alglib_version.rb'
28
- Hoe.spec 'alglib' do
29
- self.version=Alglib::VERSION
17
+
18
+ Hoe.spec 'alglib' do |p|
30
19
  self.rubyforge_name = 'ruby-statsample' # if different than 'alglib'
31
- self.developer('Claudio Bustos', 'clbustos@gmail.com')
32
- self.spec_extras= {'extensions' => ['ext/extconf.rb']}
33
- self.url = "http://rubyforge.org/projects/ruby-statsample/"
20
+ p.developer('Claudio Bustos', 'clbustos@gmail.com')
21
+ p.spec_extras= {'extensions' => ['ext/extconf.rb']}
22
+ p.url = "http://rubyforge.org/projects/ruby-statsample/"
34
23
  end
35
24
 
36
25
  # vim: syntax=ruby
@@ -1,23 +1,22 @@
1
1
  require 'rake/testtask'
2
2
  require 'rake/rdoctask'
3
- MAKEFILE="Makefile.#{RUBY_VERSION}"
3
+
4
+
4
5
  task :default => [:compile]
5
6
  task :test => ["test.rb"] do |t|
6
- ruby %(test.rb)
7
+ system %(ruby test.rb)
7
8
  end
8
9
  task :compile => ["alglib.so"]
9
-
10
- file "alglib/alglib.cpp"=>Dir.glob("*.i") do |t|
11
- puts "Reconstruyendo swig"
10
+ file "alglib/alglib.cpp"=>["alglib.i"] do |t|
11
+ puts "Reconstruyendo swig"
12
12
  system %(swig -fvirtual -Wall -c++ -o alglib/alglib.cpp -ruby alglib.i)
13
13
  end
14
-
15
-
16
14
  cpp=Dir.glob("alglib/*.cpp")+Dir.glob("alglib/*.h")
17
- file "alglib.so"=>cpp + [MAKEFILE] do |t|
18
- system %(make -f #{MAKEFILE})
15
+
16
+ file "alglib.so"=>cpp + ["Makefile"] do |t|
17
+ system %(make)
19
18
  end
20
19
 
21
- file MAKEFILE => ["extconf.rb"] do |t|
22
- ruby %( extconf.rb)
20
+ file "Makefile" => ["extconf.rb"] do |t|
21
+ system %(ruby extconf.rb)
23
22
  end
@@ -1,25 +1,160 @@
1
1
  %module alglib_ext
2
2
  %{
3
3
  #include "ap.h"
4
+ #include "linreg.h"
4
5
  #include "alglib_util.h"
5
- #include <iostream>
6
- #include <cstdio>
6
+ #include "iostream"
7
7
  %}
8
8
 
9
9
  %include "typemaps.i"
10
10
  %apply int *OUTPUT {int& info};
11
11
  %apply int *INPUT {int& nvars};
12
- %apply int *INPUT {int& nvars};
13
- %apply int *INPUT {int& nclasses};
14
- %apply double *INPUT {double &bothtails};
15
- %apply double *INPUT {double &lefttail};
16
- %apply double *INPUT {double &righttail};
17
-
18
-
19
- %include "ap.i"
20
- %include "correlation.i"
21
- %include "correlationtests.i"
22
- %include "linreg.i"
23
- %include "mannwhitneyu.i"
24
- %include "logit.i"
25
- %include "pca.i"
12
+
13
+ %typemap(in) ap::real_1d_array {
14
+ $1 = new ap::real_1d_array();
15
+ $1->setlength(RARRAY_LEN($input));
16
+ for(long i=0;i<RARRAY_LEN($input);i++) {
17
+ $1->operator()(i)=rb_num2dbl(RARRAY_PTR($input)[i]);
18
+ }
19
+ }
20
+
21
+
22
+ %apply ap::real_1d_array {ap::real_1d_array const &};
23
+
24
+ namespace ap {
25
+ /********************************************************************
26
+ Template of a dynamical one-dimensional array
27
+ ********************************************************************/
28
+ template<class T, bool Aligned = false>
29
+ class template_1d_array
30
+ {
31
+ public:
32
+ template_1d_array();
33
+ ~template_1d_array();
34
+ template_1d_array(const template_1d_array &rhs);
35
+ %extend {
36
+ T __getitem__(int i) {
37
+ return $self->operator()(i);
38
+ };
39
+ T __setitem__(int i, T v) {
40
+ return $self->operator()(i)=v;
41
+ };
42
+ int size() {
43
+ return $self->gethighbound()-$self->getlowbound();
44
+ }
45
+ }
46
+
47
+ void setbounds( int iLow, int iHigh );
48
+ void setlength(int iLen);
49
+ void setcontent( int iLow, int iHigh, const T *pContent );
50
+ T* getcontent();
51
+ int getlowbound(int iBoundNum = 0);
52
+ int gethighbound(int iBoundNum = 0);
53
+ };
54
+
55
+ template<class T, bool Aligned = false>
56
+ class template_2d_array
57
+ {
58
+ public:
59
+ template_2d_array();
60
+
61
+ ~template_2d_array();
62
+
63
+ template_2d_array(const template_2d_array &rhs);
64
+ T& operator()(int i1, int i2);
65
+
66
+ void setbounds( int iLow1, int iHigh1, int iLow2, int iHigh2 );
67
+
68
+ void setlength(int iLen1, int iLen2);
69
+
70
+ void setcontent( int iLow1, int iHigh1, int iLow2, int iHigh2, const T *pContent );
71
+
72
+ int getlowbound(int iBoundNum) const;
73
+
74
+ int gethighbound(int iBoundNum) const;
75
+
76
+ %extend {
77
+ double __getitem__(int x,int y) {
78
+ return $self->operator()(x,y);
79
+ }
80
+ void __setitem__(int x,int y, T val) {
81
+ $self->operator()(x,y)=val;
82
+ }
83
+
84
+ }
85
+
86
+ };
87
+
88
+
89
+
90
+ typedef template_1d_array<int> integer_1d_array;
91
+ typedef template_1d_array<double,true> real_1d_array;
92
+ typedef template_1d_array<complex> complex_1d_array;
93
+ typedef template_1d_array<bool> boolean_1d_array;
94
+
95
+ typedef template_2d_array<int> integer_2d_array;
96
+ typedef template_2d_array<double,true> real_2d_array;
97
+ typedef template_2d_array<complex> complex_2d_array;
98
+ typedef template_2d_array<bool> boolean_2d_array;
99
+
100
+ %template(Integer1dArray) template_1d_array<int>;
101
+ %template(Real1dArray) template_1d_array<double,true>;
102
+ %template(Boolean1dArray) template_1d_array<bool>;
103
+ %template(Integer2dArray) template_2d_array<int>;
104
+ %template(Real2dArray) template_2d_array<double,true>;
105
+ };
106
+
107
+ %rename (LinearModel) linearmodel;
108
+ %rename (LrReport) lrreport;
109
+
110
+ struct linearmodel
111
+ {
112
+ ap::real_1d_array w;
113
+ };
114
+ struct lrreport
115
+ {
116
+ ap::real_2d_array c;
117
+ double rmserror;
118
+ double avgerror;
119
+ double avgrelerror;
120
+ double cvrmserror;
121
+ double cvavgerror;
122
+ double cvavgrelerror;
123
+ int ncvdefects;
124
+ ap::integer_1d_array cvdefects;
125
+ };
126
+
127
+
128
+ void lrbuild(const ap::real_2d_array& xy,
129
+ int npoints,
130
+ int nvars,
131
+ int& info,
132
+ linearmodel& lm,
133
+ lrreport& ar);
134
+
135
+ void lrbuilds(const ap::real_2d_array& xy,
136
+ const ap::real_1d_array& s,
137
+ int npoints,
138
+ int nvars,
139
+ int& info,
140
+ linearmodel& lm,
141
+ lrreport& ar);
142
+
143
+ void lrbuildzs(const ap::real_2d_array& xy,
144
+ const ap::real_1d_array& s,
145
+ int npoints,
146
+ int nvars,
147
+ int& info,
148
+ linearmodel& lm,
149
+ lrreport& ar);
150
+ void lrbuildz(const ap::real_2d_array& xy,
151
+ int npoints,
152
+ int nvars,
153
+ int& info,
154
+ linearmodel& lm,
155
+ lrreport& ar);
156
+
157
+ void lrunpack(const linearmodel& lm, ap::real_1d_array& v, int& nvars);
158
+ void lrpack(const ap::real_1d_array& v, int nvars, linearmodel& lm);
159
+ double lrprocess(const linearmodel& lm, const ap::real_1d_array& x);
160
+ VALUE real1d_to_array(ap::real_1d_array *x);
@@ -1,6 +1,6 @@
1
1
  /* ----------------------------------------------------------------------------
2
2
  * This file was automatically generated by SWIG (http://www.swig.org).
3
- * Version 1.3.36
3
+ * Version 1.3.35
4
4
  *
5
5
  * This file is not intended to be easily readable and contains a number of
6
6
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -72,12 +72,6 @@ template <typename T> T SwigValueInit() {
72
72
  # endif
73
73
  #endif
74
74
 
75
- #ifndef SWIG_MSC_UNSUPPRESS_4505
76
- # if defined(_MSC_VER)
77
- # pragma warning(disable : 4505) /* unreferenced local function has been removed */
78
- # endif
79
- #endif
80
-
81
75
  #ifndef SWIGUNUSEDPARM
82
76
  # ifdef __cplusplus
83
77
  # define SWIGUNUSEDPARM(p)
@@ -181,12 +175,6 @@ template <typename T> T SwigValueInit() {
181
175
  # endif
182
176
  #endif
183
177
 
184
- #ifndef SWIG_MSC_UNSUPPRESS_4505
185
- # if defined(_MSC_VER)
186
- # pragma warning(disable : 4505) /* unreferenced local function has been removed */
187
- # endif
188
- #endif
189
-
190
178
  #ifndef SWIGUNUSEDPARM
191
179
  # ifdef __cplusplus
192
180
  # define SWIGUNUSEDPARM(p)
@@ -1796,12 +1784,9 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
1796
1784
  #define SWIGTYPE_p_double swig_types[10]
1797
1785
  #define SWIGTYPE_p_int swig_types[11]
1798
1786
  #define SWIGTYPE_p_linearmodel swig_types[12]
1799
- #define SWIGTYPE_p_logitmcstate swig_types[13]
1800
- #define SWIGTYPE_p_logitmodel swig_types[14]
1801
- #define SWIGTYPE_p_lrreport swig_types[15]
1802
- #define SWIGTYPE_p_mnlreport swig_types[16]
1803
- static swig_type_info *swig_types[18];
1804
- static swig_module_info swig_module = {swig_types, 17, 0, 0, 0, 0};
1787
+ #define SWIGTYPE_p_lrreport swig_types[13]
1788
+ static swig_type_info *swig_types[15];
1789
+ static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
1805
1790
  #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1806
1791
  #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1807
1792
 
@@ -1816,7 +1801,7 @@ static VALUE mAlglib_ext;
1816
1801
  #define SWIG_RUBY_THREAD_END_BLOCK
1817
1802
 
1818
1803
 
1819
- #define SWIGVERSION 0x010336
1804
+ #define SWIGVERSION 0x010335
1820
1805
  #define SWIG_VERSION SWIGVERSION
1821
1806
 
1822
1807
 
@@ -1828,9 +1813,9 @@ static VALUE mAlglib_ext;
1828
1813
 
1829
1814
 
1830
1815
  #include "ap.h"
1816
+ #include "linreg.h"
1831
1817
  #include "alglib_util.h"
1832
- #include <iostream>
1833
- #include <cstdio>
1818
+ #include "iostream"
1834
1819
 
1835
1820
 
1836
1821
  #ifdef __cplusplus
@@ -1928,11 +1913,11 @@ SWIG_From_int (int value)
1928
1913
  return SWIG_From_long (value);
1929
1914
  }
1930
1915
 
1931
- SWIGINTERN int ap_template_1d_array_Sl_int_Sg____setitem__(ap::template_1d_array< int > *self,int i,int v){
1916
+ SWIGINTERN int ap_template_1d_array_Sl_int_Sg____setitem__(ap::template_1d_array< int > *self,int i,int v){
1932
1917
  return self->operator()(i)=v;
1933
1918
  }
1934
- SWIGINTERN int ap_template_1d_array_Sl_int_Sg__size(ap::template_1d_array< int > *self){
1935
- return self->gethighbound()-self->getlowbound()+1;
1919
+ SWIGINTERN int ap_template_1d_array_Sl_int_Sg__size(ap::template_1d_array< int > *self){
1920
+ return self->gethighbound()-self->getlowbound();
1936
1921
  }
1937
1922
  SWIGINTERN double ap_template_1d_array_Sl_double_Sc_true_Sg____getitem__(ap::template_1d_array< double,true > *self,int i){
1938
1923
  return self->operator()(i);
@@ -1969,11 +1954,11 @@ SWIG_AsVal_double (VALUE obj, double *val)
1969
1954
  return SWIG_TypeError;
1970
1955
  }
1971
1956
 
1972
- SWIGINTERN double ap_template_1d_array_Sl_double_Sc_true_Sg____setitem__(ap::template_1d_array< double,true > *self,int i,double v){
1957
+ SWIGINTERN double ap_template_1d_array_Sl_double_Sc_true_Sg____setitem__(ap::template_1d_array< double,true > *self,int i,double v){
1973
1958
  return self->operator()(i)=v;
1974
1959
  }
1975
- SWIGINTERN int ap_template_1d_array_Sl_double_Sc_true_Sg__size(ap::template_1d_array< double,true > *self){
1976
- return self->gethighbound()-self->getlowbound()+1;
1960
+ SWIGINTERN int ap_template_1d_array_Sl_double_Sc_true_Sg__size(ap::template_1d_array< double,true > *self){
1961
+ return self->gethighbound()-self->getlowbound();
1977
1962
  }
1978
1963
  SWIGINTERN bool ap_template_1d_array_Sl_bool_Sg____getitem__(ap::template_1d_array< bool > *self,int i){
1979
1964
  return self->operator()(i);
@@ -2005,11 +1990,11 @@ SWIG_AsVal_bool (VALUE obj, bool *val)
2005
1990
  return SWIG_TypeError;
2006
1991
  }
2007
1992
 
2008
- SWIGINTERN bool ap_template_1d_array_Sl_bool_Sg____setitem__(ap::template_1d_array< bool > *self,int i,bool v){
1993
+ SWIGINTERN bool ap_template_1d_array_Sl_bool_Sg____setitem__(ap::template_1d_array< bool > *self,int i,bool v){
2009
1994
  return self->operator()(i)=v;
2010
1995
  }
2011
- SWIGINTERN int ap_template_1d_array_Sl_bool_Sg__size(ap::template_1d_array< bool > *self){
2012
- return self->gethighbound()-self->getlowbound()+1;
1996
+ SWIGINTERN int ap_template_1d_array_Sl_bool_Sg__size(ap::template_1d_array< bool > *self){
1997
+ return self->gethighbound()-self->getlowbound();
2013
1998
  }
2014
1999
  SWIGINTERN double ap_template_2d_array_Sl_int_Sg____getitem__(ap::template_2d_array< int > *self,int x,int y){
2015
2000
  return self->operator()(x,y);
@@ -2023,72 +2008,6 @@ SWIGINTERN double ap_template_2d_array_Sl_double_Sc_true_Sg____getitem__(ap::tem
2023
2008
  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){
2024
2009
  self->operator()(x,y)=val;
2025
2010
  }
2026
-
2027
- #include "correlation.h"
2028
- #include "ialglib.h"
2029
-
2030
-
2031
- double wrap_spearmanrankcorrelation(const ap::real_1d_array& x,
2032
- const ap::real_1d_array& y,
2033
- int n) {
2034
- ap::real_1d_array x1,y1;
2035
- x1=x;
2036
- y1=y;
2037
- return spearmanrankcorrelation(x1,y1,n);
2038
-
2039
- }
2040
-
2041
-
2042
- #include "correlationtests.h"
2043
-
2044
-
2045
- VALUE pearsoncorrelationsignificance(double r,
2046
- int n) {
2047
- VALUE ary;
2048
- double bt,lt,rt;
2049
- pearsoncorrelationsignificance(r, n, bt, lt, rt);
2050
- ary=rb_ary_new();
2051
- rb_ary_push(ary, rb_float_new(bt));
2052
- rb_ary_push(ary, rb_float_new(lt));
2053
- rb_ary_push(ary, rb_float_new(rt));
2054
- return ary;
2055
- }
2056
-
2057
-
2058
- VALUE spearmanrankcorrelationsignificance(double r,
2059
- int n) {
2060
- VALUE ary;
2061
- double bt,lt,rt;
2062
- spearmanrankcorrelationsignificance(r, n, bt, lt, rt);
2063
- ary=rb_ary_new();
2064
- rb_ary_push(ary, rb_float_new(bt));
2065
- rb_ary_push(ary, rb_float_new(lt));
2066
- rb_ary_push(ary, rb_float_new(rt));
2067
- return ary;
2068
- }
2069
-
2070
-
2071
- #include "linreg.h"
2072
-
2073
-
2074
- #include "mannwhitneyu.h"
2075
-
2076
-
2077
- #include "logit.h"
2078
-
2079
-
2080
- VALUE wrap_mnlprocess(logitmodel& lm,
2081
- const ap::real_1d_array& x) {
2082
- ap::real_1d_array y;
2083
- // y.setlength(lm.w(3));
2084
- mnlprocess(lm,x,y);
2085
- // std::cout << "Saliendo";
2086
- return real1d_to_array(&y);
2087
- }
2088
-
2089
-
2090
- #include "pca.h"
2091
-
2092
2011
  swig_class cInteger1dArray;
2093
2012
 
2094
2013
  SWIGINTERN VALUE
@@ -2098,8 +2017,8 @@ _wrap_new_Integer1dArray__SWIG_0(int argc, VALUE *argv, VALUE self) {
2098
2017
  if ((argc < 0) || (argc > 0)) {
2099
2018
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2100
2019
  }
2101
- result = (ap::template_1d_array< int > *)new ap::template_1d_array< int >();
2102
- DATA_PTR(self) = result;
2020
+ result = (ap::template_1d_array< int > *)new ap::template_1d_array< int >();DATA_PTR(self) = result;
2021
+
2103
2022
  return self;
2104
2023
  fail:
2105
2024
  return Qnil;
@@ -2131,9 +2050,9 @@ _wrap_Integer1dArray_allocate(VALUE self) {
2131
2050
  SWIGINTERN VALUE
2132
2051
  _wrap_new_Integer1dArray__SWIG_1(int argc, VALUE *argv, VALUE self) {
2133
2052
  ap::template_1d_array< int > *arg1 = 0 ;
2053
+ ap::template_1d_array< int > *result = 0 ;
2134
2054
  void *argp1 ;
2135
2055
  int res1 = 0 ;
2136
- ap::template_1d_array< int > *result = 0 ;
2137
2056
 
2138
2057
  if ((argc < 1) || (argc > 1)) {
2139
2058
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
@@ -2146,8 +2065,8 @@ _wrap_new_Integer1dArray__SWIG_1(int argc, VALUE *argv, VALUE self) {
2146
2065
  SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::template_1d_array< int > const &","ap::template_1d_array<(int)>", 1, argv[0]));
2147
2066
  }
2148
2067
  arg1 = reinterpret_cast< ap::template_1d_array< int > * >(argp1);
2149
- result = (ap::template_1d_array< int > *)new ap::template_1d_array< int >((ap::template_1d_array< int > const &)*arg1);
2150
- DATA_PTR(self) = result;
2068
+ result = (ap::template_1d_array< int > *)new ap::template_1d_array< int >((ap::template_1d_array< int > const &)*arg1);DATA_PTR(self) = result;
2069
+
2151
2070
  return self;
2152
2071
  fail:
2153
2072
  return Qnil;
@@ -2199,11 +2118,11 @@ SWIGINTERN VALUE
2199
2118
  _wrap_Integer1dArray___getitem__(int argc, VALUE *argv, VALUE self) {
2200
2119
  ap::template_1d_array< int > *arg1 = (ap::template_1d_array< int > *) 0 ;
2201
2120
  int arg2 ;
2121
+ int result;
2202
2122
  void *argp1 = 0 ;
2203
2123
  int res1 = 0 ;
2204
2124
  int val2 ;
2205
2125
  int ecode2 = 0 ;
2206
- int result;
2207
2126
  VALUE vresult = Qnil;
2208
2127
 
2209
2128
  if ((argc < 1) || (argc > 1)) {
@@ -2241,13 +2160,13 @@ _wrap_Integer1dArray___setitem__(int argc, VALUE *argv, VALUE self) {
2241
2160
  ap::template_1d_array< int > *arg1 = (ap::template_1d_array< int > *) 0 ;
2242
2161
  int arg2 ;
2243
2162
  int arg3 ;
2163
+ int result;
2244
2164
  void *argp1 = 0 ;
2245
2165
  int res1 = 0 ;
2246
2166
  int val2 ;
2247
2167
  int ecode2 = 0 ;
2248
2168
  int val3 ;
2249
2169
  int ecode3 = 0 ;
2250
- int result;
2251
2170
  VALUE vresult = Qnil;
2252
2171
 
2253
2172
  if ((argc < 2) || (argc > 2)) {
@@ -2288,9 +2207,9 @@ Size or Length of the Integer1dArray.
2288
2207
  SWIGINTERN VALUE
2289
2208
  _wrap_Integer1dArray_size(int argc, VALUE *argv, VALUE self) {
2290
2209
  ap::template_1d_array< int > *arg1 = (ap::template_1d_array< int > *) 0 ;
2210
+ int result;
2291
2211
  void *argp1 = 0 ;
2292
2212
  int res1 = 0 ;
2293
- int result;
2294
2213
  VALUE vresult = Qnil;
2295
2214
 
2296
2215
  if ((argc < 0) || (argc > 0)) {
@@ -2423,9 +2342,9 @@ fail:
2423
2342
  SWIGINTERN VALUE
2424
2343
  _wrap_Integer1dArray_getcontent(int argc, VALUE *argv, VALUE self) {
2425
2344
  ap::template_1d_array< int > *arg1 = (ap::template_1d_array< int > *) 0 ;
2345
+ int *result = 0 ;
2426
2346
  void *argp1 = 0 ;
2427
2347
  int res1 = 0 ;
2428
- int *result = 0 ;
2429
2348
  VALUE vresult = Qnil;
2430
2349
 
2431
2350
  if ((argc < 0) || (argc > 0)) {
@@ -2448,11 +2367,11 @@ SWIGINTERN VALUE
2448
2367
  _wrap_Integer1dArray_getlowbound__SWIG_0(int argc, VALUE *argv, VALUE self) {
2449
2368
  ap::template_1d_array< int > *arg1 = (ap::template_1d_array< int > *) 0 ;
2450
2369
  int arg2 ;
2370
+ int result;
2451
2371
  void *argp1 = 0 ;
2452
2372
  int res1 = 0 ;
2453
2373
  int val2 ;
2454
2374
  int ecode2 = 0 ;
2455
- int result;
2456
2375
  VALUE vresult = Qnil;
2457
2376
 
2458
2377
  if ((argc < 1) || (argc > 1)) {
@@ -2479,9 +2398,9 @@ fail:
2479
2398
  SWIGINTERN VALUE
2480
2399
  _wrap_Integer1dArray_getlowbound__SWIG_1(int argc, VALUE *argv, VALUE self) {
2481
2400
  ap::template_1d_array< int > *arg1 = (ap::template_1d_array< int > *) 0 ;
2401
+ int result;
2482
2402
  void *argp1 = 0 ;
2483
2403
  int res1 = 0 ;
2484
- int result;
2485
2404
  VALUE vresult = Qnil;
2486
2405
 
2487
2406
  if ((argc < 0) || (argc > 0)) {
@@ -2549,11 +2468,11 @@ SWIGINTERN VALUE
2549
2468
  _wrap_Integer1dArray_gethighbound__SWIG_0(int argc, VALUE *argv, VALUE self) {
2550
2469
  ap::template_1d_array< int > *arg1 = (ap::template_1d_array< int > *) 0 ;
2551
2470
  int arg2 ;
2471
+ int result;
2552
2472
  void *argp1 = 0 ;
2553
2473
  int res1 = 0 ;
2554
2474
  int val2 ;
2555
2475
  int ecode2 = 0 ;
2556
- int result;
2557
2476
  VALUE vresult = Qnil;
2558
2477
 
2559
2478
  if ((argc < 1) || (argc > 1)) {
@@ -2580,9 +2499,9 @@ fail:
2580
2499
  SWIGINTERN VALUE
2581
2500
  _wrap_Integer1dArray_gethighbound__SWIG_1(int argc, VALUE *argv, VALUE self) {
2582
2501
  ap::template_1d_array< int > *arg1 = (ap::template_1d_array< int > *) 0 ;
2502
+ int result;
2583
2503
  void *argp1 = 0 ;
2584
2504
  int res1 = 0 ;
2585
- int result;
2586
2505
  VALUE vresult = Qnil;
2587
2506
 
2588
2507
  if ((argc < 0) || (argc > 0)) {
@@ -2655,8 +2574,8 @@ _wrap_new_Real1dArray__SWIG_0(int argc, VALUE *argv, VALUE self) {
2655
2574
  if ((argc < 0) || (argc > 0)) {
2656
2575
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2657
2576
  }
2658
- result = (ap::template_1d_array< double,true > *)new ap::template_1d_array< double,true >();
2659
- DATA_PTR(self) = result;
2577
+ result = (ap::template_1d_array< double,true > *)new ap::template_1d_array< double,true >();DATA_PTR(self) = result;
2578
+
2660
2579
  return self;
2661
2580
  fail:
2662
2581
  return Qnil;
@@ -2688,9 +2607,9 @@ _wrap_Real1dArray_allocate(VALUE self) {
2688
2607
  SWIGINTERN VALUE
2689
2608
  _wrap_new_Real1dArray__SWIG_1(int argc, VALUE *argv, VALUE self) {
2690
2609
  ap::template_1d_array< double,true > *arg1 = 0 ;
2610
+ ap::template_1d_array< double,true > *result = 0 ;
2691
2611
  void *argp1 ;
2692
2612
  int res1 = 0 ;
2693
- ap::template_1d_array< double,true > *result = 0 ;
2694
2613
 
2695
2614
  if ((argc < 1) || (argc > 1)) {
2696
2615
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
@@ -2703,8 +2622,8 @@ _wrap_new_Real1dArray__SWIG_1(int argc, VALUE *argv, VALUE self) {
2703
2622
  SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::template_1d_array< double,true > const &","ap::template_1d_array<(double,true)>", 1, argv[0]));
2704
2623
  }
2705
2624
  arg1 = reinterpret_cast< ap::template_1d_array< double,true > * >(argp1);
2706
- result = (ap::template_1d_array< double,true > *)new ap::template_1d_array< double,true >((ap::template_1d_array< double,true > const &)*arg1);
2707
- DATA_PTR(self) = result;
2625
+ result = (ap::template_1d_array< double,true > *)new ap::template_1d_array< double,true >((ap::template_1d_array< double,true > const &)*arg1);DATA_PTR(self) = result;
2626
+
2708
2627
  return self;
2709
2628
  fail:
2710
2629
  return Qnil;
@@ -2756,11 +2675,11 @@ SWIGINTERN VALUE
2756
2675
  _wrap_Real1dArray___getitem__(int argc, VALUE *argv, VALUE self) {
2757
2676
  ap::template_1d_array< double,true > *arg1 = (ap::template_1d_array< double,true > *) 0 ;
2758
2677
  int arg2 ;
2678
+ double result;
2759
2679
  void *argp1 = 0 ;
2760
2680
  int res1 = 0 ;
2761
2681
  int val2 ;
2762
2682
  int ecode2 = 0 ;
2763
- double result;
2764
2683
  VALUE vresult = Qnil;
2765
2684
 
2766
2685
  if ((argc < 1) || (argc > 1)) {
@@ -2798,13 +2717,13 @@ _wrap_Real1dArray___setitem__(int argc, VALUE *argv, VALUE self) {
2798
2717
  ap::template_1d_array< double,true > *arg1 = (ap::template_1d_array< double,true > *) 0 ;
2799
2718
  int arg2 ;
2800
2719
  double arg3 ;
2720
+ double result;
2801
2721
  void *argp1 = 0 ;
2802
2722
  int res1 = 0 ;
2803
2723
  int val2 ;
2804
2724
  int ecode2 = 0 ;
2805
2725
  double val3 ;
2806
2726
  int ecode3 = 0 ;
2807
- double result;
2808
2727
  VALUE vresult = Qnil;
2809
2728
 
2810
2729
  if ((argc < 2) || (argc > 2)) {
@@ -2845,9 +2764,9 @@ Size or Length of the Real1dArray.
2845
2764
  SWIGINTERN VALUE
2846
2765
  _wrap_Real1dArray_size(int argc, VALUE *argv, VALUE self) {
2847
2766
  ap::template_1d_array< double,true > *arg1 = (ap::template_1d_array< double,true > *) 0 ;
2767
+ int result;
2848
2768
  void *argp1 = 0 ;
2849
2769
  int res1 = 0 ;
2850
- int result;
2851
2770
  VALUE vresult = Qnil;
2852
2771
 
2853
2772
  if ((argc < 0) || (argc > 0)) {
@@ -2980,9 +2899,9 @@ fail:
2980
2899
  SWIGINTERN VALUE
2981
2900
  _wrap_Real1dArray_getcontent(int argc, VALUE *argv, VALUE self) {
2982
2901
  ap::template_1d_array< double,true > *arg1 = (ap::template_1d_array< double,true > *) 0 ;
2902
+ double *result = 0 ;
2983
2903
  void *argp1 = 0 ;
2984
2904
  int res1 = 0 ;
2985
- double *result = 0 ;
2986
2905
  VALUE vresult = Qnil;
2987
2906
 
2988
2907
  if ((argc < 0) || (argc > 0)) {
@@ -3005,11 +2924,11 @@ SWIGINTERN VALUE
3005
2924
  _wrap_Real1dArray_getlowbound__SWIG_0(int argc, VALUE *argv, VALUE self) {
3006
2925
  ap::template_1d_array< double,true > *arg1 = (ap::template_1d_array< double,true > *) 0 ;
3007
2926
  int arg2 ;
2927
+ int result;
3008
2928
  void *argp1 = 0 ;
3009
2929
  int res1 = 0 ;
3010
2930
  int val2 ;
3011
2931
  int ecode2 = 0 ;
3012
- int result;
3013
2932
  VALUE vresult = Qnil;
3014
2933
 
3015
2934
  if ((argc < 1) || (argc > 1)) {
@@ -3036,9 +2955,9 @@ fail:
3036
2955
  SWIGINTERN VALUE
3037
2956
  _wrap_Real1dArray_getlowbound__SWIG_1(int argc, VALUE *argv, VALUE self) {
3038
2957
  ap::template_1d_array< double,true > *arg1 = (ap::template_1d_array< double,true > *) 0 ;
2958
+ int result;
3039
2959
  void *argp1 = 0 ;
3040
2960
  int res1 = 0 ;
3041
- int result;
3042
2961
  VALUE vresult = Qnil;
3043
2962
 
3044
2963
  if ((argc < 0) || (argc > 0)) {
@@ -3106,11 +3025,11 @@ SWIGINTERN VALUE
3106
3025
  _wrap_Real1dArray_gethighbound__SWIG_0(int argc, VALUE *argv, VALUE self) {
3107
3026
  ap::template_1d_array< double,true > *arg1 = (ap::template_1d_array< double,true > *) 0 ;
3108
3027
  int arg2 ;
3028
+ int result;
3109
3029
  void *argp1 = 0 ;
3110
3030
  int res1 = 0 ;
3111
3031
  int val2 ;
3112
3032
  int ecode2 = 0 ;
3113
- int result;
3114
3033
  VALUE vresult = Qnil;
3115
3034
 
3116
3035
  if ((argc < 1) || (argc > 1)) {
@@ -3137,9 +3056,9 @@ fail:
3137
3056
  SWIGINTERN VALUE
3138
3057
  _wrap_Real1dArray_gethighbound__SWIG_1(int argc, VALUE *argv, VALUE self) {
3139
3058
  ap::template_1d_array< double,true > *arg1 = (ap::template_1d_array< double,true > *) 0 ;
3059
+ int result;
3140
3060
  void *argp1 = 0 ;
3141
3061
  int res1 = 0 ;
3142
- int result;
3143
3062
  VALUE vresult = Qnil;
3144
3063
 
3145
3064
  if ((argc < 0) || (argc > 0)) {
@@ -3212,8 +3131,8 @@ _wrap_new_Boolean1dArray__SWIG_0(int argc, VALUE *argv, VALUE self) {
3212
3131
  if ((argc < 0) || (argc > 0)) {
3213
3132
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3214
3133
  }
3215
- result = (ap::template_1d_array< bool > *)new ap::template_1d_array< bool >();
3216
- DATA_PTR(self) = result;
3134
+ result = (ap::template_1d_array< bool > *)new ap::template_1d_array< bool >();DATA_PTR(self) = result;
3135
+
3217
3136
  return self;
3218
3137
  fail:
3219
3138
  return Qnil;
@@ -3245,9 +3164,9 @@ _wrap_Boolean1dArray_allocate(VALUE self) {
3245
3164
  SWIGINTERN VALUE
3246
3165
  _wrap_new_Boolean1dArray__SWIG_1(int argc, VALUE *argv, VALUE self) {
3247
3166
  ap::template_1d_array< bool > *arg1 = 0 ;
3167
+ ap::template_1d_array< bool > *result = 0 ;
3248
3168
  void *argp1 ;
3249
3169
  int res1 = 0 ;
3250
- ap::template_1d_array< bool > *result = 0 ;
3251
3170
 
3252
3171
  if ((argc < 1) || (argc > 1)) {
3253
3172
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
@@ -3260,8 +3179,8 @@ _wrap_new_Boolean1dArray__SWIG_1(int argc, VALUE *argv, VALUE self) {
3260
3179
  SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::template_1d_array< bool > const &","ap::template_1d_array<(bool)>", 1, argv[0]));
3261
3180
  }
3262
3181
  arg1 = reinterpret_cast< ap::template_1d_array< bool > * >(argp1);
3263
- result = (ap::template_1d_array< bool > *)new ap::template_1d_array< bool >((ap::template_1d_array< bool > const &)*arg1);
3264
- DATA_PTR(self) = result;
3182
+ result = (ap::template_1d_array< bool > *)new ap::template_1d_array< bool >((ap::template_1d_array< bool > const &)*arg1);DATA_PTR(self) = result;
3183
+
3265
3184
  return self;
3266
3185
  fail:
3267
3186
  return Qnil;
@@ -3313,11 +3232,11 @@ SWIGINTERN VALUE
3313
3232
  _wrap_Boolean1dArray___getitem__(int argc, VALUE *argv, VALUE self) {
3314
3233
  ap::template_1d_array< bool > *arg1 = (ap::template_1d_array< bool > *) 0 ;
3315
3234
  int arg2 ;
3235
+ bool result;
3316
3236
  void *argp1 = 0 ;
3317
3237
  int res1 = 0 ;
3318
3238
  int val2 ;
3319
3239
  int ecode2 = 0 ;
3320
- bool result;
3321
3240
  VALUE vresult = Qnil;
3322
3241
 
3323
3242
  if ((argc < 1) || (argc > 1)) {
@@ -3355,13 +3274,13 @@ _wrap_Boolean1dArray___setitem__(int argc, VALUE *argv, VALUE self) {
3355
3274
  ap::template_1d_array< bool > *arg1 = (ap::template_1d_array< bool > *) 0 ;
3356
3275
  int arg2 ;
3357
3276
  bool arg3 ;
3277
+ bool result;
3358
3278
  void *argp1 = 0 ;
3359
3279
  int res1 = 0 ;
3360
3280
  int val2 ;
3361
3281
  int ecode2 = 0 ;
3362
3282
  bool val3 ;
3363
3283
  int ecode3 = 0 ;
3364
- bool result;
3365
3284
  VALUE vresult = Qnil;
3366
3285
 
3367
3286
  if ((argc < 2) || (argc > 2)) {
@@ -3402,9 +3321,9 @@ Size or Length of the Boolean1dArray.
3402
3321
  SWIGINTERN VALUE
3403
3322
  _wrap_Boolean1dArray_size(int argc, VALUE *argv, VALUE self) {
3404
3323
  ap::template_1d_array< bool > *arg1 = (ap::template_1d_array< bool > *) 0 ;
3324
+ int result;
3405
3325
  void *argp1 = 0 ;
3406
3326
  int res1 = 0 ;
3407
- int result;
3408
3327
  VALUE vresult = Qnil;
3409
3328
 
3410
3329
  if ((argc < 0) || (argc > 0)) {
@@ -3537,9 +3456,9 @@ fail:
3537
3456
  SWIGINTERN VALUE
3538
3457
  _wrap_Boolean1dArray_getcontent(int argc, VALUE *argv, VALUE self) {
3539
3458
  ap::template_1d_array< bool > *arg1 = (ap::template_1d_array< bool > *) 0 ;
3459
+ bool *result = 0 ;
3540
3460
  void *argp1 = 0 ;
3541
3461
  int res1 = 0 ;
3542
- bool *result = 0 ;
3543
3462
  VALUE vresult = Qnil;
3544
3463
 
3545
3464
  if ((argc < 0) || (argc > 0)) {
@@ -3562,11 +3481,11 @@ SWIGINTERN VALUE
3562
3481
  _wrap_Boolean1dArray_getlowbound__SWIG_0(int argc, VALUE *argv, VALUE self) {
3563
3482
  ap::template_1d_array< bool > *arg1 = (ap::template_1d_array< bool > *) 0 ;
3564
3483
  int arg2 ;
3484
+ int result;
3565
3485
  void *argp1 = 0 ;
3566
3486
  int res1 = 0 ;
3567
3487
  int val2 ;
3568
3488
  int ecode2 = 0 ;
3569
- int result;
3570
3489
  VALUE vresult = Qnil;
3571
3490
 
3572
3491
  if ((argc < 1) || (argc > 1)) {
@@ -3593,9 +3512,9 @@ fail:
3593
3512
  SWIGINTERN VALUE
3594
3513
  _wrap_Boolean1dArray_getlowbound__SWIG_1(int argc, VALUE *argv, VALUE self) {
3595
3514
  ap::template_1d_array< bool > *arg1 = (ap::template_1d_array< bool > *) 0 ;
3515
+ int result;
3596
3516
  void *argp1 = 0 ;
3597
3517
  int res1 = 0 ;
3598
- int result;
3599
3518
  VALUE vresult = Qnil;
3600
3519
 
3601
3520
  if ((argc < 0) || (argc > 0)) {
@@ -3663,11 +3582,11 @@ SWIGINTERN VALUE
3663
3582
  _wrap_Boolean1dArray_gethighbound__SWIG_0(int argc, VALUE *argv, VALUE self) {
3664
3583
  ap::template_1d_array< bool > *arg1 = (ap::template_1d_array< bool > *) 0 ;
3665
3584
  int arg2 ;
3585
+ int result;
3666
3586
  void *argp1 = 0 ;
3667
3587
  int res1 = 0 ;
3668
3588
  int val2 ;
3669
3589
  int ecode2 = 0 ;
3670
- int result;
3671
3590
  VALUE vresult = Qnil;
3672
3591
 
3673
3592
  if ((argc < 1) || (argc > 1)) {
@@ -3694,9 +3613,9 @@ fail:
3694
3613
  SWIGINTERN VALUE
3695
3614
  _wrap_Boolean1dArray_gethighbound__SWIG_1(int argc, VALUE *argv, VALUE self) {
3696
3615
  ap::template_1d_array< bool > *arg1 = (ap::template_1d_array< bool > *) 0 ;
3616
+ int result;
3697
3617
  void *argp1 = 0 ;
3698
3618
  int res1 = 0 ;
3699
- int result;
3700
3619
  VALUE vresult = Qnil;
3701
3620
 
3702
3621
  if ((argc < 0) || (argc > 0)) {
@@ -3769,8 +3688,8 @@ _wrap_new_Integer2dArray__SWIG_0(int argc, VALUE *argv, VALUE self) {
3769
3688
  if ((argc < 0) || (argc > 0)) {
3770
3689
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3771
3690
  }
3772
- result = (ap::template_2d_array< int > *)new ap::template_2d_array< int >();
3773
- DATA_PTR(self) = result;
3691
+ result = (ap::template_2d_array< int > *)new ap::template_2d_array< int >();DATA_PTR(self) = result;
3692
+
3774
3693
  return self;
3775
3694
  fail:
3776
3695
  return Qnil;
@@ -3802,9 +3721,9 @@ _wrap_Integer2dArray_allocate(VALUE self) {
3802
3721
  SWIGINTERN VALUE
3803
3722
  _wrap_new_Integer2dArray__SWIG_1(int argc, VALUE *argv, VALUE self) {
3804
3723
  ap::template_2d_array< int > *arg1 = 0 ;
3724
+ ap::template_2d_array< int > *result = 0 ;
3805
3725
  void *argp1 ;
3806
3726
  int res1 = 0 ;
3807
- ap::template_2d_array< int > *result = 0 ;
3808
3727
 
3809
3728
  if ((argc < 1) || (argc > 1)) {
3810
3729
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
@@ -3817,8 +3736,8 @@ _wrap_new_Integer2dArray__SWIG_1(int argc, VALUE *argv, VALUE self) {
3817
3736
  SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::template_2d_array< int > const &","ap::template_2d_array<(int)>", 1, argv[0]));
3818
3737
  }
3819
3738
  arg1 = reinterpret_cast< ap::template_2d_array< int > * >(argp1);
3820
- result = (ap::template_2d_array< int > *)new ap::template_2d_array< int >((ap::template_2d_array< int > const &)*arg1);
3821
- DATA_PTR(self) = result;
3739
+ result = (ap::template_2d_array< int > *)new ap::template_2d_array< int >((ap::template_2d_array< int > const &)*arg1);DATA_PTR(self) = result;
3740
+
3822
3741
  return self;
3823
3742
  fail:
3824
3743
  return Qnil;
@@ -3862,13 +3781,13 @@ _wrap_Integer2dArray___call__(int argc, VALUE *argv, VALUE self) {
3862
3781
  ap::template_2d_array< int > *arg1 = (ap::template_2d_array< int > *) 0 ;
3863
3782
  int arg2 ;
3864
3783
  int arg3 ;
3784
+ int *result = 0 ;
3865
3785
  void *argp1 = 0 ;
3866
3786
  int res1 = 0 ;
3867
3787
  int val2 ;
3868
3788
  int ecode2 = 0 ;
3869
3789
  int val3 ;
3870
3790
  int ecode3 = 0 ;
3871
- int *result = 0 ;
3872
3791
  VALUE vresult = Qnil;
3873
3792
 
3874
3793
  if ((argc < 2) || (argc > 2)) {
@@ -4055,11 +3974,11 @@ SWIGINTERN VALUE
4055
3974
  _wrap_Integer2dArray_getlowbound(int argc, VALUE *argv, VALUE self) {
4056
3975
  ap::template_2d_array< int > *arg1 = (ap::template_2d_array< int > *) 0 ;
4057
3976
  int arg2 ;
3977
+ int result;
4058
3978
  void *argp1 = 0 ;
4059
3979
  int res1 = 0 ;
4060
3980
  int val2 ;
4061
3981
  int ecode2 = 0 ;
4062
- int result;
4063
3982
  VALUE vresult = Qnil;
4064
3983
 
4065
3984
  if ((argc < 1) || (argc > 1)) {
@@ -4087,11 +4006,11 @@ SWIGINTERN VALUE
4087
4006
  _wrap_Integer2dArray_gethighbound(int argc, VALUE *argv, VALUE self) {
4088
4007
  ap::template_2d_array< int > *arg1 = (ap::template_2d_array< int > *) 0 ;
4089
4008
  int arg2 ;
4009
+ int result;
4090
4010
  void *argp1 = 0 ;
4091
4011
  int res1 = 0 ;
4092
4012
  int val2 ;
4093
4013
  int ecode2 = 0 ;
4094
- int result;
4095
4014
  VALUE vresult = Qnil;
4096
4015
 
4097
4016
  if ((argc < 1) || (argc > 1)) {
@@ -4129,13 +4048,13 @@ _wrap_Integer2dArray___getitem__(int argc, VALUE *argv, VALUE self) {
4129
4048
  ap::template_2d_array< int > *arg1 = (ap::template_2d_array< int > *) 0 ;
4130
4049
  int arg2 ;
4131
4050
  int arg3 ;
4051
+ double result;
4132
4052
  void *argp1 = 0 ;
4133
4053
  int res1 = 0 ;
4134
4054
  int val2 ;
4135
4055
  int ecode2 = 0 ;
4136
4056
  int val3 ;
4137
4057
  int ecode3 = 0 ;
4138
- double result;
4139
4058
  VALUE vresult = Qnil;
4140
4059
 
4141
4060
  if ((argc < 2) || (argc > 2)) {
@@ -4227,8 +4146,8 @@ _wrap_new_Real2dArray__SWIG_0(int argc, VALUE *argv, VALUE self) {
4227
4146
  if ((argc < 0) || (argc > 0)) {
4228
4147
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4229
4148
  }
4230
- result = (ap::template_2d_array< double,true > *)new ap::template_2d_array< double,true >();
4231
- DATA_PTR(self) = result;
4149
+ result = (ap::template_2d_array< double,true > *)new ap::template_2d_array< double,true >();DATA_PTR(self) = result;
4150
+
4232
4151
  return self;
4233
4152
  fail:
4234
4153
  return Qnil;
@@ -4260,9 +4179,9 @@ _wrap_Real2dArray_allocate(VALUE self) {
4260
4179
  SWIGINTERN VALUE
4261
4180
  _wrap_new_Real2dArray__SWIG_1(int argc, VALUE *argv, VALUE self) {
4262
4181
  ap::template_2d_array< double,true > *arg1 = 0 ;
4182
+ ap::template_2d_array< double,true > *result = 0 ;
4263
4183
  void *argp1 ;
4264
4184
  int res1 = 0 ;
4265
- ap::template_2d_array< double,true > *result = 0 ;
4266
4185
 
4267
4186
  if ((argc < 1) || (argc > 1)) {
4268
4187
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
@@ -4275,8 +4194,8 @@ _wrap_new_Real2dArray__SWIG_1(int argc, VALUE *argv, VALUE self) {
4275
4194
  SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::template_2d_array< double,true > const &","ap::template_2d_array<(double,true)>", 1, argv[0]));
4276
4195
  }
4277
4196
  arg1 = reinterpret_cast< ap::template_2d_array< double,true > * >(argp1);
4278
- result = (ap::template_2d_array< double,true > *)new ap::template_2d_array< double,true >((ap::template_2d_array< double,true > const &)*arg1);
4279
- DATA_PTR(self) = result;
4197
+ result = (ap::template_2d_array< double,true > *)new ap::template_2d_array< double,true >((ap::template_2d_array< double,true > const &)*arg1);DATA_PTR(self) = result;
4198
+
4280
4199
  return self;
4281
4200
  fail:
4282
4201
  return Qnil;
@@ -4320,13 +4239,13 @@ _wrap_Real2dArray___call__(int argc, VALUE *argv, VALUE self) {
4320
4239
  ap::template_2d_array< double,true > *arg1 = (ap::template_2d_array< double,true > *) 0 ;
4321
4240
  int arg2 ;
4322
4241
  int arg3 ;
4242
+ double *result = 0 ;
4323
4243
  void *argp1 = 0 ;
4324
4244
  int res1 = 0 ;
4325
4245
  int val2 ;
4326
4246
  int ecode2 = 0 ;
4327
4247
  int val3 ;
4328
4248
  int ecode3 = 0 ;
4329
- double *result = 0 ;
4330
4249
  VALUE vresult = Qnil;
4331
4250
 
4332
4251
  if ((argc < 2) || (argc > 2)) {
@@ -4513,11 +4432,11 @@ SWIGINTERN VALUE
4513
4432
  _wrap_Real2dArray_getlowbound(int argc, VALUE *argv, VALUE self) {
4514
4433
  ap::template_2d_array< double,true > *arg1 = (ap::template_2d_array< double,true > *) 0 ;
4515
4434
  int arg2 ;
4435
+ int result;
4516
4436
  void *argp1 = 0 ;
4517
4437
  int res1 = 0 ;
4518
4438
  int val2 ;
4519
4439
  int ecode2 = 0 ;
4520
- int result;
4521
4440
  VALUE vresult = Qnil;
4522
4441
 
4523
4442
  if ((argc < 1) || (argc > 1)) {
@@ -4545,11 +4464,11 @@ SWIGINTERN VALUE
4545
4464
  _wrap_Real2dArray_gethighbound(int argc, VALUE *argv, VALUE self) {
4546
4465
  ap::template_2d_array< double,true > *arg1 = (ap::template_2d_array< double,true > *) 0 ;
4547
4466
  int arg2 ;
4467
+ int result;
4548
4468
  void *argp1 = 0 ;
4549
4469
  int res1 = 0 ;
4550
4470
  int val2 ;
4551
4471
  int ecode2 = 0 ;
4552
- int result;
4553
4472
  VALUE vresult = Qnil;
4554
4473
 
4555
4474
  if ((argc < 1) || (argc > 1)) {
@@ -4587,13 +4506,13 @@ _wrap_Real2dArray___getitem__(int argc, VALUE *argv, VALUE self) {
4587
4506
  ap::template_2d_array< double,true > *arg1 = (ap::template_2d_array< double,true > *) 0 ;
4588
4507
  int arg2 ;
4589
4508
  int arg3 ;
4509
+ double result;
4590
4510
  void *argp1 = 0 ;
4591
4511
  int res1 = 0 ;
4592
4512
  int val2 ;
4593
4513
  int ecode2 = 0 ;
4594
4514
  int val3 ;
4595
4515
  int ecode3 = 0 ;
4596
- double result;
4597
4516
  VALUE vresult = Qnil;
4598
4517
 
4599
4518
  if ((argc < 2) || (argc > 2)) {
@@ -4676,47 +4595,32 @@ fail:
4676
4595
  }
4677
4596
 
4678
4597
 
4598
+ swig_class cLinearModel;
4599
+
4679
4600
  SWIGINTERN VALUE
4680
- _wrap_real1d_to_array(int argc, VALUE *argv, VALUE self) {
4681
- ap::real_1d_array *arg1 = (ap::real_1d_array *) 0 ;
4601
+ _wrap_LinearModel_w_set(int argc, VALUE *argv, VALUE self) {
4602
+ linearmodel *arg1 = (linearmodel *) 0 ;
4603
+ ap::real_1d_array *arg2 = (ap::real_1d_array *) 0 ;
4682
4604
  void *argp1 = 0 ;
4683
4605
  int res1 = 0 ;
4684
- VALUE result;
4685
- VALUE vresult = Qnil;
4606
+ void *argp2 = 0 ;
4607
+ int res2 = 0 ;
4686
4608
 
4687
4609
  if ((argc < 1) || (argc > 1)) {
4688
4610
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4689
4611
  }
4690
- res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 | 0 );
4612
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_linearmodel, 0 | 0 );
4691
4613
  if (!SWIG_IsOK(res1)) {
4692
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ap::real_1d_array *","real1d_to_array", 1, argv[0] ));
4693
- }
4694
- arg1 = reinterpret_cast< ap::real_1d_array * >(argp1);
4695
- result = (VALUE)real1d_to_array(arg1);
4696
- vresult = result;
4697
- return vresult;
4698
- fail:
4699
- return Qnil;
4700
- }
4701
-
4702
-
4703
- SWIGINTERN VALUE
4704
- _wrap_array_to_real1d(int argc, VALUE *argv, VALUE self) {
4705
- VALUE arg1 = (VALUE) 0 ;
4706
- ap::real_1d_array *arg2 = (ap::real_1d_array *) 0 ;
4707
- void *argp2 = 0 ;
4708
- int res2 = 0 ;
4709
-
4710
- if ((argc < 2) || (argc > 2)) {
4711
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
4614
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "linearmodel *","w", 1, self ));
4712
4615
  }
4713
- arg1 = argv[0];
4714
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 | 0 );
4616
+ arg1 = reinterpret_cast< linearmodel * >(argp1);
4617
+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 | 0 );
4715
4618
  if (!SWIG_IsOK(res2)) {
4716
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "ap::real_1d_array *","array_to_real1d", 2, argv[1] ));
4619
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "ap::real_1d_array *","w", 2, argv[0] ));
4717
4620
  }
4718
4621
  arg2 = reinterpret_cast< ap::real_1d_array * >(argp2);
4719
- array_to_real1d(arg1,arg2);
4622
+ if (arg1) (arg1)->w = *arg2;
4623
+
4720
4624
  return Qnil;
4721
4625
  fail:
4722
4626
  return Qnil;
@@ -4724,242 +4628,67 @@ fail:
4724
4628
 
4725
4629
 
4726
4630
  SWIGINTERN VALUE
4727
- _wrap_pearsoncorrelation(int argc, VALUE *argv, VALUE self) {
4728
- ap::real_1d_array *arg1 = 0 ;
4729
- ap::real_1d_array *arg2 = 0 ;
4730
- int arg3 ;
4731
- int val3 ;
4732
- int ecode3 = 0 ;
4733
- double result;
4631
+ _wrap_LinearModel_w_get(int argc, VALUE *argv, VALUE self) {
4632
+ linearmodel *arg1 = (linearmodel *) 0 ;
4633
+ ap::real_1d_array *result = 0 ;
4634
+ void *argp1 = 0 ;
4635
+ int res1 = 0 ;
4734
4636
  VALUE vresult = Qnil;
4735
4637
 
4736
- if ((argc < 3) || (argc > 3)) {
4737
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
4738
- }
4739
- {
4740
- arg1 = new ap::real_1d_array();
4741
- arg1->setlength(RARRAY_LEN(argv[0]));
4742
- for(long i=0;i<RARRAY_LEN(argv[0]);i++) {
4743
- arg1->operator()(i)=rb_num2dbl(RARRAY_PTR(argv[0])[i]);
4744
- }
4638
+ if ((argc < 0) || (argc > 0)) {
4639
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4745
4640
  }
4746
- {
4747
- arg2 = new ap::real_1d_array();
4748
- arg2->setlength(RARRAY_LEN(argv[1]));
4749
- for(long i=0;i<RARRAY_LEN(argv[1]);i++) {
4750
- arg2->operator()(i)=rb_num2dbl(RARRAY_PTR(argv[1])[i]);
4751
- }
4641
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_linearmodel, 0 | 0 );
4642
+ if (!SWIG_IsOK(res1)) {
4643
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "linearmodel *","w", 1, self ));
4752
4644
  }
4753
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
4754
- if (!SWIG_IsOK(ecode3)) {
4755
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","pearsoncorrelation", 3, argv[2] ));
4756
- }
4757
- arg3 = static_cast< int >(val3);
4758
- result = (double)pearsoncorrelation((ap::template_1d_array< double,true > const &)*arg1,(ap::template_1d_array< double,true > const &)*arg2,arg3);
4759
- vresult = SWIG_From_double(static_cast< double >(result));
4645
+ arg1 = reinterpret_cast< linearmodel * >(argp1);
4646
+ result = (ap::real_1d_array *)& ((arg1)->w);
4647
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 | 0 );
4760
4648
  return vresult;
4761
4649
  fail:
4762
4650
  return Qnil;
4763
4651
  }
4764
4652
 
4765
4653
 
4654
+ #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
4766
4655
  SWIGINTERN VALUE
4767
- _wrap_spearmanrankcorrelation(int argc, VALUE *argv, VALUE self) {
4768
- ap::real_1d_array *arg1 = 0 ;
4769
- ap::real_1d_array *arg2 = 0 ;
4770
- int arg3 ;
4771
- int val3 ;
4772
- int ecode3 = 0 ;
4773
- double result;
4774
- VALUE vresult = Qnil;
4775
-
4776
- if ((argc < 3) || (argc > 3)) {
4777
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
4778
- }
4779
- {
4780
- arg1 = new ap::real_1d_array();
4781
- arg1->setlength(RARRAY_LEN(argv[0]));
4782
- for(long i=0;i<RARRAY_LEN(argv[0]);i++) {
4783
- arg1->operator()(i)=rb_num2dbl(RARRAY_PTR(argv[0])[i]);
4784
- }
4656
+ _wrap_LinearModel_allocate(VALUE self) {
4657
+ #else
4658
+ SWIGINTERN VALUE
4659
+ _wrap_LinearModel_allocate(int argc, VALUE *argv, VALUE self) {
4660
+ #endif
4661
+
4662
+
4663
+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_linearmodel);
4664
+ #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
4665
+ rb_obj_call_init(vresult, argc, argv);
4666
+ #endif
4667
+ return vresult;
4785
4668
  }
4786
- {
4787
- arg2 = new ap::real_1d_array();
4788
- arg2->setlength(RARRAY_LEN(argv[1]));
4789
- for(long i=0;i<RARRAY_LEN(argv[1]);i++) {
4790
- arg2->operator()(i)=rb_num2dbl(RARRAY_PTR(argv[1])[i]);
4791
- }
4669
+
4670
+
4671
+ SWIGINTERN VALUE
4672
+ _wrap_new_LinearModel(int argc, VALUE *argv, VALUE self) {
4673
+ linearmodel *result = 0 ;
4674
+
4675
+ if ((argc < 0) || (argc > 0)) {
4676
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4792
4677
  }
4793
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
4794
- if (!SWIG_IsOK(ecode3)) {
4795
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","wrap_spearmanrankcorrelation", 3, argv[2] ));
4796
- }
4797
- arg3 = static_cast< int >(val3);
4798
- result = (double)wrap_spearmanrankcorrelation((ap::template_1d_array< double,true > const &)*arg1,(ap::template_1d_array< double,true > const &)*arg2,arg3);
4799
- vresult = SWIG_From_double(static_cast< double >(result));
4800
- return vresult;
4678
+ result = (linearmodel *)new linearmodel();DATA_PTR(self) = result;
4679
+
4680
+ return self;
4801
4681
  fail:
4802
4682
  return Qnil;
4803
4683
  }
4804
4684
 
4805
-
4806
- SWIGINTERN VALUE
4807
- _wrap_pearsoncorrelationsignificance(int argc, VALUE *argv, VALUE self) {
4808
- double arg1 ;
4809
- int arg2 ;
4810
- double val1 ;
4811
- int ecode1 = 0 ;
4812
- int val2 ;
4813
- int ecode2 = 0 ;
4814
- VALUE result;
4815
- VALUE vresult = Qnil;
4816
-
4817
- if ((argc < 2) || (argc > 2)) {
4818
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
4819
- }
4820
- ecode1 = SWIG_AsVal_double(argv[0], &val1);
4821
- if (!SWIG_IsOK(ecode1)) {
4822
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","pearsoncorrelationsignificance", 1, argv[0] ));
4823
- }
4824
- arg1 = static_cast< double >(val1);
4825
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
4826
- if (!SWIG_IsOK(ecode2)) {
4827
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pearsoncorrelationsignificance", 2, argv[1] ));
4828
- }
4829
- arg2 = static_cast< int >(val2);
4830
- result = (VALUE)pearsoncorrelationsignificance(arg1,arg2);
4831
- vresult = result;
4832
- return vresult;
4833
- fail:
4834
- return Qnil;
4835
- }
4836
-
4837
-
4838
- SWIGINTERN VALUE
4839
- _wrap_spearmanrankcorrelationsignificance(int argc, VALUE *argv, VALUE self) {
4840
- double arg1 ;
4841
- int arg2 ;
4842
- double val1 ;
4843
- int ecode1 = 0 ;
4844
- int val2 ;
4845
- int ecode2 = 0 ;
4846
- VALUE result;
4847
- VALUE vresult = Qnil;
4848
-
4849
- if ((argc < 2) || (argc > 2)) {
4850
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
4851
- }
4852
- ecode1 = SWIG_AsVal_double(argv[0], &val1);
4853
- if (!SWIG_IsOK(ecode1)) {
4854
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","spearmanrankcorrelationsignificance", 1, argv[0] ));
4855
- }
4856
- arg1 = static_cast< double >(val1);
4857
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
4858
- if (!SWIG_IsOK(ecode2)) {
4859
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","spearmanrankcorrelationsignificance", 2, argv[1] ));
4860
- }
4861
- arg2 = static_cast< int >(val2);
4862
- result = (VALUE)spearmanrankcorrelationsignificance(arg1,arg2);
4863
- vresult = result;
4864
- return vresult;
4865
- fail:
4866
- return Qnil;
4867
- }
4868
-
4869
-
4870
- swig_class cLinearModel;
4871
-
4872
- SWIGINTERN VALUE
4873
- _wrap_LinearModel_w_set(int argc, VALUE *argv, VALUE self) {
4874
- linearmodel *arg1 = (linearmodel *) 0 ;
4875
- ap::real_1d_array *arg2 = (ap::real_1d_array *) 0 ;
4876
- void *argp1 = 0 ;
4877
- int res1 = 0 ;
4878
- void *argp2 = 0 ;
4879
- int res2 = 0 ;
4880
-
4881
- if ((argc < 1) || (argc > 1)) {
4882
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4883
- }
4884
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_linearmodel, 0 | 0 );
4885
- if (!SWIG_IsOK(res1)) {
4886
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "linearmodel *","w", 1, self ));
4887
- }
4888
- arg1 = reinterpret_cast< linearmodel * >(argp1);
4889
- res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 | 0 );
4890
- if (!SWIG_IsOK(res2)) {
4891
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "ap::real_1d_array *","w", 2, argv[0] ));
4892
- }
4893
- arg2 = reinterpret_cast< ap::real_1d_array * >(argp2);
4894
- if (arg1) (arg1)->w = *arg2;
4895
- return Qnil;
4896
- fail:
4897
- return Qnil;
4898
- }
4899
-
4900
-
4901
- SWIGINTERN VALUE
4902
- _wrap_LinearModel_w_get(int argc, VALUE *argv, VALUE self) {
4903
- linearmodel *arg1 = (linearmodel *) 0 ;
4904
- void *argp1 = 0 ;
4905
- int res1 = 0 ;
4906
- ap::real_1d_array *result = 0 ;
4907
- VALUE vresult = Qnil;
4908
-
4909
- if ((argc < 0) || (argc > 0)) {
4910
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4911
- }
4912
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_linearmodel, 0 | 0 );
4913
- if (!SWIG_IsOK(res1)) {
4914
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "linearmodel *","w", 1, self ));
4915
- }
4916
- arg1 = reinterpret_cast< linearmodel * >(argp1);
4917
- result = (ap::real_1d_array *)& ((arg1)->w);
4918
- vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 | 0 );
4919
- return vresult;
4920
- fail:
4921
- return Qnil;
4922
- }
4923
-
4924
-
4925
- #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
4926
- SWIGINTERN VALUE
4927
- _wrap_LinearModel_allocate(VALUE self) {
4928
- #else
4929
- SWIGINTERN VALUE
4930
- _wrap_LinearModel_allocate(int argc, VALUE *argv, VALUE self) {
4931
- #endif
4932
-
4933
-
4934
- VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_linearmodel);
4935
- #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
4936
- rb_obj_call_init(vresult, argc, argv);
4937
- #endif
4938
- return vresult;
4939
- }
4940
-
4941
-
4942
- SWIGINTERN VALUE
4943
- _wrap_new_LinearModel(int argc, VALUE *argv, VALUE self) {
4944
- linearmodel *result = 0 ;
4945
-
4946
- if ((argc < 0) || (argc > 0)) {
4947
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4948
- }
4949
- result = (linearmodel *)new linearmodel();
4950
- DATA_PTR(self) = result;
4951
- return self;
4952
- fail:
4953
- return Qnil;
4954
- }
4955
-
4956
-
4957
- SWIGINTERN void
4958
- free_linearmodel(linearmodel *arg1) {
4959
- delete arg1;
4960
- }
4961
-
4962
- swig_class cLrReport;
4685
+
4686
+ SWIGINTERN void
4687
+ free_linearmodel(linearmodel *arg1) {
4688
+ delete arg1;
4689
+ }
4690
+
4691
+ swig_class cLrReport;
4963
4692
 
4964
4693
  SWIGINTERN VALUE
4965
4694
  _wrap_LrReport_c_set(int argc, VALUE *argv, VALUE self) {
@@ -4984,6 +4713,7 @@ _wrap_LrReport_c_set(int argc, VALUE *argv, VALUE self) {
4984
4713
  }
4985
4714
  arg2 = reinterpret_cast< ap::real_2d_array * >(argp2);
4986
4715
  if (arg1) (arg1)->c = *arg2;
4716
+
4987
4717
  return Qnil;
4988
4718
  fail:
4989
4719
  return Qnil;
@@ -4993,9 +4723,9 @@ fail:
4993
4723
  SWIGINTERN VALUE
4994
4724
  _wrap_LrReport_c_get(int argc, VALUE *argv, VALUE self) {
4995
4725
  lrreport *arg1 = (lrreport *) 0 ;
4726
+ ap::real_2d_array *result = 0 ;
4996
4727
  void *argp1 = 0 ;
4997
4728
  int res1 = 0 ;
4998
- ap::real_2d_array *result = 0 ;
4999
4729
  VALUE vresult = Qnil;
5000
4730
 
5001
4731
  if ((argc < 0) || (argc > 0)) {
@@ -5037,6 +4767,7 @@ _wrap_LrReport_rmserror_set(int argc, VALUE *argv, VALUE self) {
5037
4767
  }
5038
4768
  arg2 = static_cast< double >(val2);
5039
4769
  if (arg1) (arg1)->rmserror = arg2;
4770
+
5040
4771
  return Qnil;
5041
4772
  fail:
5042
4773
  return Qnil;
@@ -5046,9 +4777,9 @@ fail:
5046
4777
  SWIGINTERN VALUE
5047
4778
  _wrap_LrReport_rmserror_get(int argc, VALUE *argv, VALUE self) {
5048
4779
  lrreport *arg1 = (lrreport *) 0 ;
4780
+ double result;
5049
4781
  void *argp1 = 0 ;
5050
4782
  int res1 = 0 ;
5051
- double result;
5052
4783
  VALUE vresult = Qnil;
5053
4784
 
5054
4785
  if ((argc < 0) || (argc > 0)) {
@@ -5090,6 +4821,7 @@ _wrap_LrReport_avgerror_set(int argc, VALUE *argv, VALUE self) {
5090
4821
  }
5091
4822
  arg2 = static_cast< double >(val2);
5092
4823
  if (arg1) (arg1)->avgerror = arg2;
4824
+
5093
4825
  return Qnil;
5094
4826
  fail:
5095
4827
  return Qnil;
@@ -5099,9 +4831,9 @@ fail:
5099
4831
  SWIGINTERN VALUE
5100
4832
  _wrap_LrReport_avgerror_get(int argc, VALUE *argv, VALUE self) {
5101
4833
  lrreport *arg1 = (lrreport *) 0 ;
4834
+ double result;
5102
4835
  void *argp1 = 0 ;
5103
4836
  int res1 = 0 ;
5104
- double result;
5105
4837
  VALUE vresult = Qnil;
5106
4838
 
5107
4839
  if ((argc < 0) || (argc > 0)) {
@@ -5143,6 +4875,7 @@ _wrap_LrReport_avgrelerror_set(int argc, VALUE *argv, VALUE self) {
5143
4875
  }
5144
4876
  arg2 = static_cast< double >(val2);
5145
4877
  if (arg1) (arg1)->avgrelerror = arg2;
4878
+
5146
4879
  return Qnil;
5147
4880
  fail:
5148
4881
  return Qnil;
@@ -5152,9 +4885,9 @@ fail:
5152
4885
  SWIGINTERN VALUE
5153
4886
  _wrap_LrReport_avgrelerror_get(int argc, VALUE *argv, VALUE self) {
5154
4887
  lrreport *arg1 = (lrreport *) 0 ;
4888
+ double result;
5155
4889
  void *argp1 = 0 ;
5156
4890
  int res1 = 0 ;
5157
- double result;
5158
4891
  VALUE vresult = Qnil;
5159
4892
 
5160
4893
  if ((argc < 0) || (argc > 0)) {
@@ -5196,6 +4929,7 @@ _wrap_LrReport_cvrmserror_set(int argc, VALUE *argv, VALUE self) {
5196
4929
  }
5197
4930
  arg2 = static_cast< double >(val2);
5198
4931
  if (arg1) (arg1)->cvrmserror = arg2;
4932
+
5199
4933
  return Qnil;
5200
4934
  fail:
5201
4935
  return Qnil;
@@ -5205,9 +4939,9 @@ fail:
5205
4939
  SWIGINTERN VALUE
5206
4940
  _wrap_LrReport_cvrmserror_get(int argc, VALUE *argv, VALUE self) {
5207
4941
  lrreport *arg1 = (lrreport *) 0 ;
4942
+ double result;
5208
4943
  void *argp1 = 0 ;
5209
4944
  int res1 = 0 ;
5210
- double result;
5211
4945
  VALUE vresult = Qnil;
5212
4946
 
5213
4947
  if ((argc < 0) || (argc > 0)) {
@@ -5249,6 +4983,7 @@ _wrap_LrReport_cvavgerror_set(int argc, VALUE *argv, VALUE self) {
5249
4983
  }
5250
4984
  arg2 = static_cast< double >(val2);
5251
4985
  if (arg1) (arg1)->cvavgerror = arg2;
4986
+
5252
4987
  return Qnil;
5253
4988
  fail:
5254
4989
  return Qnil;
@@ -5258,9 +4993,9 @@ fail:
5258
4993
  SWIGINTERN VALUE
5259
4994
  _wrap_LrReport_cvavgerror_get(int argc, VALUE *argv, VALUE self) {
5260
4995
  lrreport *arg1 = (lrreport *) 0 ;
4996
+ double result;
5261
4997
  void *argp1 = 0 ;
5262
4998
  int res1 = 0 ;
5263
- double result;
5264
4999
  VALUE vresult = Qnil;
5265
5000
 
5266
5001
  if ((argc < 0) || (argc > 0)) {
@@ -5302,6 +5037,7 @@ _wrap_LrReport_cvavgrelerror_set(int argc, VALUE *argv, VALUE self) {
5302
5037
  }
5303
5038
  arg2 = static_cast< double >(val2);
5304
5039
  if (arg1) (arg1)->cvavgrelerror = arg2;
5040
+
5305
5041
  return Qnil;
5306
5042
  fail:
5307
5043
  return Qnil;
@@ -5311,9 +5047,9 @@ fail:
5311
5047
  SWIGINTERN VALUE
5312
5048
  _wrap_LrReport_cvavgrelerror_get(int argc, VALUE *argv, VALUE self) {
5313
5049
  lrreport *arg1 = (lrreport *) 0 ;
5050
+ double result;
5314
5051
  void *argp1 = 0 ;
5315
5052
  int res1 = 0 ;
5316
- double result;
5317
5053
  VALUE vresult = Qnil;
5318
5054
 
5319
5055
  if ((argc < 0) || (argc > 0)) {
@@ -5355,6 +5091,7 @@ _wrap_LrReport_ncvdefects_set(int argc, VALUE *argv, VALUE self) {
5355
5091
  }
5356
5092
  arg2 = static_cast< int >(val2);
5357
5093
  if (arg1) (arg1)->ncvdefects = arg2;
5094
+
5358
5095
  return Qnil;
5359
5096
  fail:
5360
5097
  return Qnil;
@@ -5364,9 +5101,9 @@ fail:
5364
5101
  SWIGINTERN VALUE
5365
5102
  _wrap_LrReport_ncvdefects_get(int argc, VALUE *argv, VALUE self) {
5366
5103
  lrreport *arg1 = (lrreport *) 0 ;
5104
+ int result;
5367
5105
  void *argp1 = 0 ;
5368
5106
  int res1 = 0 ;
5369
- int result;
5370
5107
  VALUE vresult = Qnil;
5371
5108
 
5372
5109
  if ((argc < 0) || (argc > 0)) {
@@ -5408,6 +5145,7 @@ _wrap_LrReport_cvdefects_set(int argc, VALUE *argv, VALUE self) {
5408
5145
  }
5409
5146
  arg2 = reinterpret_cast< ap::integer_1d_array * >(argp2);
5410
5147
  if (arg1) (arg1)->cvdefects = *arg2;
5148
+
5411
5149
  return Qnil;
5412
5150
  fail:
5413
5151
  return Qnil;
@@ -5417,9 +5155,9 @@ fail:
5417
5155
  SWIGINTERN VALUE
5418
5156
  _wrap_LrReport_cvdefects_get(int argc, VALUE *argv, VALUE self) {
5419
5157
  lrreport *arg1 = (lrreport *) 0 ;
5158
+ ap::integer_1d_array *result = 0 ;
5420
5159
  void *argp1 = 0 ;
5421
5160
  int res1 = 0 ;
5422
- ap::integer_1d_array *result = 0 ;
5423
5161
  VALUE vresult = Qnil;
5424
5162
 
5425
5163
  if ((argc < 0) || (argc > 0)) {
@@ -5462,8 +5200,8 @@ _wrap_new_LrReport(int argc, VALUE *argv, VALUE self) {
5462
5200
  if ((argc < 0) || (argc > 0)) {
5463
5201
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5464
5202
  }
5465
- result = (lrreport *)new lrreport();
5466
- DATA_PTR(self) = result;
5203
+ result = (lrreport *)new lrreport();DATA_PTR(self) = result;
5204
+
5467
5205
  return self;
5468
5206
  fail:
5469
5207
  return Qnil;
@@ -5877,9 +5615,9 @@ SWIGINTERN VALUE
5877
5615
  _wrap_lrprocess(int argc, VALUE *argv, VALUE self) {
5878
5616
  linearmodel *arg1 = 0 ;
5879
5617
  ap::real_1d_array *arg2 = 0 ;
5618
+ double result;
5880
5619
  void *argp1 ;
5881
5620
  int res1 = 0 ;
5882
- double result;
5883
5621
  VALUE vresult = Qnil;
5884
5622
 
5885
5623
  if ((argc < 2) || (argc > 2)) {
@@ -5909,2162 +5647,31 @@ fail:
5909
5647
 
5910
5648
 
5911
5649
  SWIGINTERN VALUE
5912
- _wrap_mannwhitneyutest(int argc, VALUE *argv, VALUE self) {
5913
- ap::real_1d_array *arg1 = 0 ;
5914
- int arg2 ;
5915
- ap::real_1d_array *arg3 = 0 ;
5916
- int arg4 ;
5917
- double *arg5 = 0 ;
5918
- double *arg6 = 0 ;
5919
- double *arg7 = 0 ;
5920
- int val2 ;
5921
- int ecode2 = 0 ;
5922
- int val4 ;
5923
- int ecode4 = 0 ;
5924
- double temp5 ;
5925
- int res5 = 0 ;
5926
- double temp6 ;
5927
- int res6 = 0 ;
5928
- double temp7 ;
5929
- int res7 = 0 ;
5930
-
5931
- if ((argc < 7) || (argc > 7)) {
5932
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
5933
- }
5934
- {
5935
- arg1 = new ap::real_1d_array();
5936
- arg1->setlength(RARRAY_LEN(argv[0]));
5937
- for(long i=0;i<RARRAY_LEN(argv[0]);i++) {
5938
- arg1->operator()(i)=rb_num2dbl(RARRAY_PTR(argv[0])[i]);
5939
- }
5940
- }
5941
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
5942
- if (!SWIG_IsOK(ecode2)) {
5943
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","mannwhitneyutest", 2, argv[1] ));
5944
- }
5945
- arg2 = static_cast< int >(val2);
5946
- {
5947
- arg3 = new ap::real_1d_array();
5948
- arg3->setlength(RARRAY_LEN(argv[2]));
5949
- for(long i=0;i<RARRAY_LEN(argv[2]);i++) {
5950
- arg3->operator()(i)=rb_num2dbl(RARRAY_PTR(argv[2])[i]);
5951
- }
5952
- }
5953
- ecode4 = SWIG_AsVal_int(argv[3], &val4);
5954
- if (!SWIG_IsOK(ecode4)) {
5955
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","mannwhitneyutest", 4, argv[3] ));
5956
- }
5957
- arg4 = static_cast< int >(val4);
5958
- if (!(SWIG_IsOK((res5 = SWIG_ConvertPtr(argv[4],SWIG_as_voidptrptr(&arg5),SWIGTYPE_p_double,0))))) {
5959
- double val;
5960
- int ecode = SWIG_AsVal_double(argv[4], &val);
5961
- if (!SWIG_IsOK(ecode)) {
5962
- SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "double","mannwhitneyutest", 5, argv[4] ));
5963
- }
5964
- temp5 = static_cast< double >(val);
5965
- arg5 = &temp5;
5966
- res5 = SWIG_AddTmpMask(ecode);
5967
- }
5968
- if (!(SWIG_IsOK((res6 = SWIG_ConvertPtr(argv[5],SWIG_as_voidptrptr(&arg6),SWIGTYPE_p_double,0))))) {
5969
- double val;
5970
- int ecode = SWIG_AsVal_double(argv[5], &val);
5971
- if (!SWIG_IsOK(ecode)) {
5972
- SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "double","mannwhitneyutest", 6, argv[5] ));
5973
- }
5974
- temp6 = static_cast< double >(val);
5975
- arg6 = &temp6;
5976
- res6 = SWIG_AddTmpMask(ecode);
5977
- }
5978
- if (!(SWIG_IsOK((res7 = SWIG_ConvertPtr(argv[6],SWIG_as_voidptrptr(&arg7),SWIGTYPE_p_double,0))))) {
5979
- double val;
5980
- int ecode = SWIG_AsVal_double(argv[6], &val);
5981
- if (!SWIG_IsOK(ecode)) {
5982
- SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "double","mannwhitneyutest", 7, argv[6] ));
5983
- }
5984
- temp7 = static_cast< double >(val);
5985
- arg7 = &temp7;
5986
- res7 = SWIG_AddTmpMask(ecode);
5987
- }
5988
- mannwhitneyutest((ap::template_1d_array< double,true > const &)*arg1,arg2,(ap::template_1d_array< double,true > const &)*arg3,arg4,*arg5,*arg6,*arg7);
5989
- if (SWIG_IsNewObj(res5)) delete arg5;
5990
- if (SWIG_IsNewObj(res6)) delete arg6;
5991
- if (SWIG_IsNewObj(res7)) delete arg7;
5992
- return Qnil;
5993
- fail:
5994
- if (SWIG_IsNewObj(res5)) delete arg5;
5995
- if (SWIG_IsNewObj(res6)) delete arg6;
5996
- if (SWIG_IsNewObj(res7)) delete arg7;
5997
- return Qnil;
5998
- }
5999
-
6000
-
6001
- swig_class cLogitModel;
6002
-
6003
- SWIGINTERN VALUE
6004
- _wrap_LogitModel_w_set(int argc, VALUE *argv, VALUE self) {
6005
- logitmodel *arg1 = (logitmodel *) 0 ;
6006
- ap::real_1d_array *arg2 = (ap::real_1d_array *) 0 ;
5650
+ _wrap_real1d_to_array(int argc, VALUE *argv, VALUE self) {
5651
+ ap::real_1d_array *arg1 = (ap::real_1d_array *) 0 ;
5652
+ VALUE result;
6007
5653
  void *argp1 = 0 ;
6008
5654
  int res1 = 0 ;
6009
- void *argp2 = 0 ;
6010
- int res2 = 0 ;
5655
+ VALUE vresult = Qnil;
6011
5656
 
6012
5657
  if ((argc < 1) || (argc > 1)) {
6013
5658
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6014
5659
  }
6015
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmodel, 0 | 0 );
5660
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 | 0 );
6016
5661
  if (!SWIG_IsOK(res1)) {
6017
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmodel *","w", 1, self ));
6018
- }
6019
- arg1 = reinterpret_cast< logitmodel * >(argp1);
6020
- res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 | 0 );
6021
- if (!SWIG_IsOK(res2)) {
6022
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "ap::real_1d_array *","w", 2, argv[0] ));
5662
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ap::real_1d_array *","real1d_to_array", 1, argv[0] ));
6023
5663
  }
6024
- arg2 = reinterpret_cast< ap::real_1d_array * >(argp2);
6025
- if (arg1) (arg1)->w = *arg2;
6026
- return Qnil;
5664
+ arg1 = reinterpret_cast< ap::real_1d_array * >(argp1);
5665
+ result = (VALUE)real1d_to_array(arg1);
5666
+ vresult = result;
5667
+ return vresult;
6027
5668
  fail:
6028
5669
  return Qnil;
6029
5670
  }
6030
5671
 
6031
5672
 
6032
- SWIGINTERN VALUE
6033
- _wrap_LogitModel_w_get(int argc, VALUE *argv, VALUE self) {
6034
- logitmodel *arg1 = (logitmodel *) 0 ;
6035
- void *argp1 = 0 ;
6036
- int res1 = 0 ;
6037
- ap::real_1d_array *result = 0 ;
6038
- VALUE vresult = Qnil;
6039
-
6040
- if ((argc < 0) || (argc > 0)) {
6041
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6042
- }
6043
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmodel, 0 | 0 );
6044
- if (!SWIG_IsOK(res1)) {
6045
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmodel *","w", 1, self ));
6046
- }
6047
- arg1 = reinterpret_cast< logitmodel * >(argp1);
6048
- result = (ap::real_1d_array *)& ((arg1)->w);
6049
- vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 | 0 );
6050
- return vresult;
6051
- fail:
6052
- return Qnil;
6053
- }
6054
5673
 
6055
-
6056
- #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
6057
- SWIGINTERN VALUE
6058
- _wrap_LogitModel_allocate(VALUE self) {
6059
- #else
6060
- SWIGINTERN VALUE
6061
- _wrap_LogitModel_allocate(int argc, VALUE *argv, VALUE self) {
6062
- #endif
6063
-
6064
-
6065
- VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_logitmodel);
6066
- #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
6067
- rb_obj_call_init(vresult, argc, argv);
6068
- #endif
6069
- return vresult;
6070
- }
6071
-
6072
-
6073
- SWIGINTERN VALUE
6074
- _wrap_new_LogitModel(int argc, VALUE *argv, VALUE self) {
6075
- logitmodel *result = 0 ;
6076
-
6077
- if ((argc < 0) || (argc > 0)) {
6078
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6079
- }
6080
- result = (logitmodel *)new logitmodel();
6081
- DATA_PTR(self) = result;
6082
- return self;
6083
- fail:
6084
- return Qnil;
6085
- }
6086
-
6087
-
6088
- SWIGINTERN void
6089
- free_logitmodel(logitmodel *arg1) {
6090
- delete arg1;
6091
- }
6092
-
6093
- swig_class cLogitMcState;
6094
-
6095
- SWIGINTERN VALUE
6096
- _wrap_LogitMcState_brackt_set(int argc, VALUE *argv, VALUE self) {
6097
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6098
- bool arg2 ;
6099
- void *argp1 = 0 ;
6100
- int res1 = 0 ;
6101
- bool val2 ;
6102
- int ecode2 = 0 ;
6103
-
6104
- if ((argc < 1) || (argc > 1)) {
6105
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6106
- }
6107
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6108
- if (!SWIG_IsOK(res1)) {
6109
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","brackt", 1, self ));
6110
- }
6111
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6112
- ecode2 = SWIG_AsVal_bool(argv[0], &val2);
6113
- if (!SWIG_IsOK(ecode2)) {
6114
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","brackt", 2, argv[0] ));
6115
- }
6116
- arg2 = static_cast< bool >(val2);
6117
- if (arg1) (arg1)->brackt = arg2;
6118
- return Qnil;
6119
- fail:
6120
- return Qnil;
6121
- }
6122
-
6123
-
6124
- SWIGINTERN VALUE
6125
- _wrap_LogitMcState_brackt_get(int argc, VALUE *argv, VALUE self) {
6126
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6127
- void *argp1 = 0 ;
6128
- int res1 = 0 ;
6129
- bool result;
6130
- VALUE vresult = Qnil;
6131
-
6132
- if ((argc < 0) || (argc > 0)) {
6133
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6134
- }
6135
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6136
- if (!SWIG_IsOK(res1)) {
6137
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","brackt", 1, self ));
6138
- }
6139
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6140
- result = (bool) ((arg1)->brackt);
6141
- vresult = SWIG_From_bool(static_cast< bool >(result));
6142
- return vresult;
6143
- fail:
6144
- return Qnil;
6145
- }
6146
-
6147
-
6148
- SWIGINTERN VALUE
6149
- _wrap_LogitMcState_stage1_set(int argc, VALUE *argv, VALUE self) {
6150
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6151
- bool arg2 ;
6152
- void *argp1 = 0 ;
6153
- int res1 = 0 ;
6154
- bool val2 ;
6155
- int ecode2 = 0 ;
6156
-
6157
- if ((argc < 1) || (argc > 1)) {
6158
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6159
- }
6160
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6161
- if (!SWIG_IsOK(res1)) {
6162
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stage1", 1, self ));
6163
- }
6164
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6165
- ecode2 = SWIG_AsVal_bool(argv[0], &val2);
6166
- if (!SWIG_IsOK(ecode2)) {
6167
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","stage1", 2, argv[0] ));
6168
- }
6169
- arg2 = static_cast< bool >(val2);
6170
- if (arg1) (arg1)->stage1 = arg2;
6171
- return Qnil;
6172
- fail:
6173
- return Qnil;
6174
- }
6175
-
6176
-
6177
- SWIGINTERN VALUE
6178
- _wrap_LogitMcState_stage1_get(int argc, VALUE *argv, VALUE self) {
6179
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6180
- void *argp1 = 0 ;
6181
- int res1 = 0 ;
6182
- bool result;
6183
- VALUE vresult = Qnil;
6184
-
6185
- if ((argc < 0) || (argc > 0)) {
6186
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6187
- }
6188
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6189
- if (!SWIG_IsOK(res1)) {
6190
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stage1", 1, self ));
6191
- }
6192
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6193
- result = (bool) ((arg1)->stage1);
6194
- vresult = SWIG_From_bool(static_cast< bool >(result));
6195
- return vresult;
6196
- fail:
6197
- return Qnil;
6198
- }
6199
-
6200
-
6201
- SWIGINTERN VALUE
6202
- _wrap_LogitMcState_infoc_set(int argc, VALUE *argv, VALUE self) {
6203
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6204
- int arg2 ;
6205
- void *argp1 = 0 ;
6206
- int res1 = 0 ;
6207
- int val2 ;
6208
- int ecode2 = 0 ;
6209
-
6210
- if ((argc < 1) || (argc > 1)) {
6211
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6212
- }
6213
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6214
- if (!SWIG_IsOK(res1)) {
6215
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","infoc", 1, self ));
6216
- }
6217
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6218
- ecode2 = SWIG_AsVal_int(argv[0], &val2);
6219
- if (!SWIG_IsOK(ecode2)) {
6220
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","infoc", 2, argv[0] ));
6221
- }
6222
- arg2 = static_cast< int >(val2);
6223
- if (arg1) (arg1)->infoc = arg2;
6224
- return Qnil;
6225
- fail:
6226
- return Qnil;
6227
- }
6228
-
6229
-
6230
- SWIGINTERN VALUE
6231
- _wrap_LogitMcState_infoc_get(int argc, VALUE *argv, VALUE self) {
6232
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6233
- void *argp1 = 0 ;
6234
- int res1 = 0 ;
6235
- int result;
6236
- VALUE vresult = Qnil;
6237
-
6238
- if ((argc < 0) || (argc > 0)) {
6239
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6240
- }
6241
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6242
- if (!SWIG_IsOK(res1)) {
6243
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","infoc", 1, self ));
6244
- }
6245
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6246
- result = (int) ((arg1)->infoc);
6247
- vresult = SWIG_From_int(static_cast< int >(result));
6248
- return vresult;
6249
- fail:
6250
- return Qnil;
6251
- }
6252
-
6253
-
6254
- SWIGINTERN VALUE
6255
- _wrap_LogitMcState_dg_set(int argc, VALUE *argv, VALUE self) {
6256
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6257
- double arg2 ;
6258
- void *argp1 = 0 ;
6259
- int res1 = 0 ;
6260
- double val2 ;
6261
- int ecode2 = 0 ;
6262
-
6263
- if ((argc < 1) || (argc > 1)) {
6264
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6265
- }
6266
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6267
- if (!SWIG_IsOK(res1)) {
6268
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dg", 1, self ));
6269
- }
6270
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6271
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
6272
- if (!SWIG_IsOK(ecode2)) {
6273
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dg", 2, argv[0] ));
6274
- }
6275
- arg2 = static_cast< double >(val2);
6276
- if (arg1) (arg1)->dg = arg2;
6277
- return Qnil;
6278
- fail:
6279
- return Qnil;
6280
- }
6281
-
6282
-
6283
- SWIGINTERN VALUE
6284
- _wrap_LogitMcState_dg_get(int argc, VALUE *argv, VALUE self) {
6285
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6286
- void *argp1 = 0 ;
6287
- int res1 = 0 ;
6288
- double result;
6289
- VALUE vresult = Qnil;
6290
-
6291
- if ((argc < 0) || (argc > 0)) {
6292
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6293
- }
6294
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6295
- if (!SWIG_IsOK(res1)) {
6296
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dg", 1, self ));
6297
- }
6298
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6299
- result = (double) ((arg1)->dg);
6300
- vresult = SWIG_From_double(static_cast< double >(result));
6301
- return vresult;
6302
- fail:
6303
- return Qnil;
6304
- }
6305
-
6306
-
6307
- SWIGINTERN VALUE
6308
- _wrap_LogitMcState_dgm_set(int argc, VALUE *argv, VALUE self) {
6309
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6310
- double arg2 ;
6311
- void *argp1 = 0 ;
6312
- int res1 = 0 ;
6313
- double val2 ;
6314
- int ecode2 = 0 ;
6315
-
6316
- if ((argc < 1) || (argc > 1)) {
6317
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6318
- }
6319
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6320
- if (!SWIG_IsOK(res1)) {
6321
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgm", 1, self ));
6322
- }
6323
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6324
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
6325
- if (!SWIG_IsOK(ecode2)) {
6326
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dgm", 2, argv[0] ));
6327
- }
6328
- arg2 = static_cast< double >(val2);
6329
- if (arg1) (arg1)->dgm = arg2;
6330
- return Qnil;
6331
- fail:
6332
- return Qnil;
6333
- }
6334
-
6335
-
6336
- SWIGINTERN VALUE
6337
- _wrap_LogitMcState_dgm_get(int argc, VALUE *argv, VALUE self) {
6338
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6339
- void *argp1 = 0 ;
6340
- int res1 = 0 ;
6341
- double result;
6342
- VALUE vresult = Qnil;
6343
-
6344
- if ((argc < 0) || (argc > 0)) {
6345
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6346
- }
6347
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6348
- if (!SWIG_IsOK(res1)) {
6349
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgm", 1, self ));
6350
- }
6351
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6352
- result = (double) ((arg1)->dgm);
6353
- vresult = SWIG_From_double(static_cast< double >(result));
6354
- return vresult;
6355
- fail:
6356
- return Qnil;
6357
- }
6358
-
6359
-
6360
- SWIGINTERN VALUE
6361
- _wrap_LogitMcState_dginit_set(int argc, VALUE *argv, VALUE self) {
6362
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6363
- double arg2 ;
6364
- void *argp1 = 0 ;
6365
- int res1 = 0 ;
6366
- double val2 ;
6367
- int ecode2 = 0 ;
6368
-
6369
- if ((argc < 1) || (argc > 1)) {
6370
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6371
- }
6372
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6373
- if (!SWIG_IsOK(res1)) {
6374
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dginit", 1, self ));
6375
- }
6376
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6377
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
6378
- if (!SWIG_IsOK(ecode2)) {
6379
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dginit", 2, argv[0] ));
6380
- }
6381
- arg2 = static_cast< double >(val2);
6382
- if (arg1) (arg1)->dginit = arg2;
6383
- return Qnil;
6384
- fail:
6385
- return Qnil;
6386
- }
6387
-
6388
-
6389
- SWIGINTERN VALUE
6390
- _wrap_LogitMcState_dginit_get(int argc, VALUE *argv, VALUE self) {
6391
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6392
- void *argp1 = 0 ;
6393
- int res1 = 0 ;
6394
- double result;
6395
- VALUE vresult = Qnil;
6396
-
6397
- if ((argc < 0) || (argc > 0)) {
6398
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6399
- }
6400
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6401
- if (!SWIG_IsOK(res1)) {
6402
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dginit", 1, self ));
6403
- }
6404
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6405
- result = (double) ((arg1)->dginit);
6406
- vresult = SWIG_From_double(static_cast< double >(result));
6407
- return vresult;
6408
- fail:
6409
- return Qnil;
6410
- }
6411
-
6412
-
6413
- SWIGINTERN VALUE
6414
- _wrap_LogitMcState_dgtest_set(int argc, VALUE *argv, VALUE self) {
6415
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6416
- double arg2 ;
6417
- void *argp1 = 0 ;
6418
- int res1 = 0 ;
6419
- double val2 ;
6420
- int ecode2 = 0 ;
6421
-
6422
- if ((argc < 1) || (argc > 1)) {
6423
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6424
- }
6425
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6426
- if (!SWIG_IsOK(res1)) {
6427
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgtest", 1, self ));
6428
- }
6429
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6430
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
6431
- if (!SWIG_IsOK(ecode2)) {
6432
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dgtest", 2, argv[0] ));
6433
- }
6434
- arg2 = static_cast< double >(val2);
6435
- if (arg1) (arg1)->dgtest = arg2;
6436
- return Qnil;
6437
- fail:
6438
- return Qnil;
6439
- }
6440
-
6441
-
6442
- SWIGINTERN VALUE
6443
- _wrap_LogitMcState_dgtest_get(int argc, VALUE *argv, VALUE self) {
6444
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6445
- void *argp1 = 0 ;
6446
- int res1 = 0 ;
6447
- double result;
6448
- VALUE vresult = Qnil;
6449
-
6450
- if ((argc < 0) || (argc > 0)) {
6451
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6452
- }
6453
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6454
- if (!SWIG_IsOK(res1)) {
6455
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgtest", 1, self ));
6456
- }
6457
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6458
- result = (double) ((arg1)->dgtest);
6459
- vresult = SWIG_From_double(static_cast< double >(result));
6460
- return vresult;
6461
- fail:
6462
- return Qnil;
6463
- }
6464
-
6465
-
6466
- SWIGINTERN VALUE
6467
- _wrap_LogitMcState_dgx_set(int argc, VALUE *argv, VALUE self) {
6468
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6469
- double arg2 ;
6470
- void *argp1 = 0 ;
6471
- int res1 = 0 ;
6472
- double val2 ;
6473
- int ecode2 = 0 ;
6474
-
6475
- if ((argc < 1) || (argc > 1)) {
6476
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6477
- }
6478
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6479
- if (!SWIG_IsOK(res1)) {
6480
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgx", 1, self ));
6481
- }
6482
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6483
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
6484
- if (!SWIG_IsOK(ecode2)) {
6485
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dgx", 2, argv[0] ));
6486
- }
6487
- arg2 = static_cast< double >(val2);
6488
- if (arg1) (arg1)->dgx = arg2;
6489
- return Qnil;
6490
- fail:
6491
- return Qnil;
6492
- }
6493
-
6494
-
6495
- SWIGINTERN VALUE
6496
- _wrap_LogitMcState_dgx_get(int argc, VALUE *argv, VALUE self) {
6497
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6498
- void *argp1 = 0 ;
6499
- int res1 = 0 ;
6500
- double result;
6501
- VALUE vresult = Qnil;
6502
-
6503
- if ((argc < 0) || (argc > 0)) {
6504
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6505
- }
6506
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6507
- if (!SWIG_IsOK(res1)) {
6508
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgx", 1, self ));
6509
- }
6510
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6511
- result = (double) ((arg1)->dgx);
6512
- vresult = SWIG_From_double(static_cast< double >(result));
6513
- return vresult;
6514
- fail:
6515
- return Qnil;
6516
- }
6517
-
6518
-
6519
- SWIGINTERN VALUE
6520
- _wrap_LogitMcState_dgxm_set(int argc, VALUE *argv, VALUE self) {
6521
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6522
- double arg2 ;
6523
- void *argp1 = 0 ;
6524
- int res1 = 0 ;
6525
- double val2 ;
6526
- int ecode2 = 0 ;
6527
-
6528
- if ((argc < 1) || (argc > 1)) {
6529
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6530
- }
6531
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6532
- if (!SWIG_IsOK(res1)) {
6533
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgxm", 1, self ));
6534
- }
6535
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6536
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
6537
- if (!SWIG_IsOK(ecode2)) {
6538
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dgxm", 2, argv[0] ));
6539
- }
6540
- arg2 = static_cast< double >(val2);
6541
- if (arg1) (arg1)->dgxm = arg2;
6542
- return Qnil;
6543
- fail:
6544
- return Qnil;
6545
- }
6546
-
6547
-
6548
- SWIGINTERN VALUE
6549
- _wrap_LogitMcState_dgxm_get(int argc, VALUE *argv, VALUE self) {
6550
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6551
- void *argp1 = 0 ;
6552
- int res1 = 0 ;
6553
- double result;
6554
- VALUE vresult = Qnil;
6555
-
6556
- if ((argc < 0) || (argc > 0)) {
6557
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6558
- }
6559
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6560
- if (!SWIG_IsOK(res1)) {
6561
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgxm", 1, self ));
6562
- }
6563
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6564
- result = (double) ((arg1)->dgxm);
6565
- vresult = SWIG_From_double(static_cast< double >(result));
6566
- return vresult;
6567
- fail:
6568
- return Qnil;
6569
- }
6570
-
6571
-
6572
- SWIGINTERN VALUE
6573
- _wrap_LogitMcState_dgy_set(int argc, VALUE *argv, VALUE self) {
6574
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6575
- double arg2 ;
6576
- void *argp1 = 0 ;
6577
- int res1 = 0 ;
6578
- double val2 ;
6579
- int ecode2 = 0 ;
6580
-
6581
- if ((argc < 1) || (argc > 1)) {
6582
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6583
- }
6584
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6585
- if (!SWIG_IsOK(res1)) {
6586
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgy", 1, self ));
6587
- }
6588
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6589
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
6590
- if (!SWIG_IsOK(ecode2)) {
6591
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dgy", 2, argv[0] ));
6592
- }
6593
- arg2 = static_cast< double >(val2);
6594
- if (arg1) (arg1)->dgy = arg2;
6595
- return Qnil;
6596
- fail:
6597
- return Qnil;
6598
- }
6599
-
6600
-
6601
- SWIGINTERN VALUE
6602
- _wrap_LogitMcState_dgy_get(int argc, VALUE *argv, VALUE self) {
6603
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6604
- void *argp1 = 0 ;
6605
- int res1 = 0 ;
6606
- double result;
6607
- VALUE vresult = Qnil;
6608
-
6609
- if ((argc < 0) || (argc > 0)) {
6610
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6611
- }
6612
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6613
- if (!SWIG_IsOK(res1)) {
6614
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgy", 1, self ));
6615
- }
6616
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6617
- result = (double) ((arg1)->dgy);
6618
- vresult = SWIG_From_double(static_cast< double >(result));
6619
- return vresult;
6620
- fail:
6621
- return Qnil;
6622
- }
6623
-
6624
-
6625
- SWIGINTERN VALUE
6626
- _wrap_LogitMcState_dgym_set(int argc, VALUE *argv, VALUE self) {
6627
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6628
- double arg2 ;
6629
- void *argp1 = 0 ;
6630
- int res1 = 0 ;
6631
- double val2 ;
6632
- int ecode2 = 0 ;
6633
-
6634
- if ((argc < 1) || (argc > 1)) {
6635
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6636
- }
6637
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6638
- if (!SWIG_IsOK(res1)) {
6639
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgym", 1, self ));
6640
- }
6641
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6642
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
6643
- if (!SWIG_IsOK(ecode2)) {
6644
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","dgym", 2, argv[0] ));
6645
- }
6646
- arg2 = static_cast< double >(val2);
6647
- if (arg1) (arg1)->dgym = arg2;
6648
- return Qnil;
6649
- fail:
6650
- return Qnil;
6651
- }
6652
-
6653
-
6654
- SWIGINTERN VALUE
6655
- _wrap_LogitMcState_dgym_get(int argc, VALUE *argv, VALUE self) {
6656
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6657
- void *argp1 = 0 ;
6658
- int res1 = 0 ;
6659
- double result;
6660
- VALUE vresult = Qnil;
6661
-
6662
- if ((argc < 0) || (argc > 0)) {
6663
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6664
- }
6665
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6666
- if (!SWIG_IsOK(res1)) {
6667
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","dgym", 1, self ));
6668
- }
6669
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6670
- result = (double) ((arg1)->dgym);
6671
- vresult = SWIG_From_double(static_cast< double >(result));
6672
- return vresult;
6673
- fail:
6674
- return Qnil;
6675
- }
6676
-
6677
-
6678
- SWIGINTERN VALUE
6679
- _wrap_LogitMcState_finit_set(int argc, VALUE *argv, VALUE self) {
6680
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6681
- double arg2 ;
6682
- void *argp1 = 0 ;
6683
- int res1 = 0 ;
6684
- double val2 ;
6685
- int ecode2 = 0 ;
6686
-
6687
- if ((argc < 1) || (argc > 1)) {
6688
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6689
- }
6690
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6691
- if (!SWIG_IsOK(res1)) {
6692
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","finit", 1, self ));
6693
- }
6694
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6695
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
6696
- if (!SWIG_IsOK(ecode2)) {
6697
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","finit", 2, argv[0] ));
6698
- }
6699
- arg2 = static_cast< double >(val2);
6700
- if (arg1) (arg1)->finit = arg2;
6701
- return Qnil;
6702
- fail:
6703
- return Qnil;
6704
- }
6705
-
6706
-
6707
- SWIGINTERN VALUE
6708
- _wrap_LogitMcState_finit_get(int argc, VALUE *argv, VALUE self) {
6709
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6710
- void *argp1 = 0 ;
6711
- int res1 = 0 ;
6712
- double result;
6713
- VALUE vresult = Qnil;
6714
-
6715
- if ((argc < 0) || (argc > 0)) {
6716
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6717
- }
6718
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6719
- if (!SWIG_IsOK(res1)) {
6720
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","finit", 1, self ));
6721
- }
6722
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6723
- result = (double) ((arg1)->finit);
6724
- vresult = SWIG_From_double(static_cast< double >(result));
6725
- return vresult;
6726
- fail:
6727
- return Qnil;
6728
- }
6729
-
6730
-
6731
- SWIGINTERN VALUE
6732
- _wrap_LogitMcState_ftest1_set(int argc, VALUE *argv, VALUE self) {
6733
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6734
- double arg2 ;
6735
- void *argp1 = 0 ;
6736
- int res1 = 0 ;
6737
- double val2 ;
6738
- int ecode2 = 0 ;
6739
-
6740
- if ((argc < 1) || (argc > 1)) {
6741
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6742
- }
6743
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6744
- if (!SWIG_IsOK(res1)) {
6745
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","ftest1", 1, self ));
6746
- }
6747
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6748
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
6749
- if (!SWIG_IsOK(ecode2)) {
6750
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","ftest1", 2, argv[0] ));
6751
- }
6752
- arg2 = static_cast< double >(val2);
6753
- if (arg1) (arg1)->ftest1 = arg2;
6754
- return Qnil;
6755
- fail:
6756
- return Qnil;
6757
- }
6758
-
6759
-
6760
- SWIGINTERN VALUE
6761
- _wrap_LogitMcState_ftest1_get(int argc, VALUE *argv, VALUE self) {
6762
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6763
- void *argp1 = 0 ;
6764
- int res1 = 0 ;
6765
- double result;
6766
- VALUE vresult = Qnil;
6767
-
6768
- if ((argc < 0) || (argc > 0)) {
6769
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6770
- }
6771
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6772
- if (!SWIG_IsOK(res1)) {
6773
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","ftest1", 1, self ));
6774
- }
6775
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6776
- result = (double) ((arg1)->ftest1);
6777
- vresult = SWIG_From_double(static_cast< double >(result));
6778
- return vresult;
6779
- fail:
6780
- return Qnil;
6781
- }
6782
-
6783
-
6784
- SWIGINTERN VALUE
6785
- _wrap_LogitMcState_fm_set(int argc, VALUE *argv, VALUE self) {
6786
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6787
- double arg2 ;
6788
- void *argp1 = 0 ;
6789
- int res1 = 0 ;
6790
- double val2 ;
6791
- int ecode2 = 0 ;
6792
-
6793
- if ((argc < 1) || (argc > 1)) {
6794
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6795
- }
6796
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6797
- if (!SWIG_IsOK(res1)) {
6798
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fm", 1, self ));
6799
- }
6800
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6801
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
6802
- if (!SWIG_IsOK(ecode2)) {
6803
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","fm", 2, argv[0] ));
6804
- }
6805
- arg2 = static_cast< double >(val2);
6806
- if (arg1) (arg1)->fm = arg2;
6807
- return Qnil;
6808
- fail:
6809
- return Qnil;
6810
- }
6811
-
6812
-
6813
- SWIGINTERN VALUE
6814
- _wrap_LogitMcState_fm_get(int argc, VALUE *argv, VALUE self) {
6815
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6816
- void *argp1 = 0 ;
6817
- int res1 = 0 ;
6818
- double result;
6819
- VALUE vresult = Qnil;
6820
-
6821
- if ((argc < 0) || (argc > 0)) {
6822
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6823
- }
6824
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6825
- if (!SWIG_IsOK(res1)) {
6826
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fm", 1, self ));
6827
- }
6828
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6829
- result = (double) ((arg1)->fm);
6830
- vresult = SWIG_From_double(static_cast< double >(result));
6831
- return vresult;
6832
- fail:
6833
- return Qnil;
6834
- }
6835
-
6836
-
6837
- SWIGINTERN VALUE
6838
- _wrap_LogitMcState_fx_set(int argc, VALUE *argv, VALUE self) {
6839
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6840
- double arg2 ;
6841
- void *argp1 = 0 ;
6842
- int res1 = 0 ;
6843
- double val2 ;
6844
- int ecode2 = 0 ;
6845
-
6846
- if ((argc < 1) || (argc > 1)) {
6847
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6848
- }
6849
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6850
- if (!SWIG_IsOK(res1)) {
6851
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fx", 1, self ));
6852
- }
6853
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6854
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
6855
- if (!SWIG_IsOK(ecode2)) {
6856
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","fx", 2, argv[0] ));
6857
- }
6858
- arg2 = static_cast< double >(val2);
6859
- if (arg1) (arg1)->fx = arg2;
6860
- return Qnil;
6861
- fail:
6862
- return Qnil;
6863
- }
6864
-
6865
-
6866
- SWIGINTERN VALUE
6867
- _wrap_LogitMcState_fx_get(int argc, VALUE *argv, VALUE self) {
6868
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6869
- void *argp1 = 0 ;
6870
- int res1 = 0 ;
6871
- double result;
6872
- VALUE vresult = Qnil;
6873
-
6874
- if ((argc < 0) || (argc > 0)) {
6875
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6876
- }
6877
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6878
- if (!SWIG_IsOK(res1)) {
6879
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fx", 1, self ));
6880
- }
6881
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6882
- result = (double) ((arg1)->fx);
6883
- vresult = SWIG_From_double(static_cast< double >(result));
6884
- return vresult;
6885
- fail:
6886
- return Qnil;
6887
- }
6888
-
6889
-
6890
- SWIGINTERN VALUE
6891
- _wrap_LogitMcState_fxm_set(int argc, VALUE *argv, VALUE self) {
6892
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6893
- double arg2 ;
6894
- void *argp1 = 0 ;
6895
- int res1 = 0 ;
6896
- double val2 ;
6897
- int ecode2 = 0 ;
6898
-
6899
- if ((argc < 1) || (argc > 1)) {
6900
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6901
- }
6902
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6903
- if (!SWIG_IsOK(res1)) {
6904
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fxm", 1, self ));
6905
- }
6906
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6907
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
6908
- if (!SWIG_IsOK(ecode2)) {
6909
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","fxm", 2, argv[0] ));
6910
- }
6911
- arg2 = static_cast< double >(val2);
6912
- if (arg1) (arg1)->fxm = arg2;
6913
- return Qnil;
6914
- fail:
6915
- return Qnil;
6916
- }
6917
-
6918
-
6919
- SWIGINTERN VALUE
6920
- _wrap_LogitMcState_fxm_get(int argc, VALUE *argv, VALUE self) {
6921
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6922
- void *argp1 = 0 ;
6923
- int res1 = 0 ;
6924
- double result;
6925
- VALUE vresult = Qnil;
6926
-
6927
- if ((argc < 0) || (argc > 0)) {
6928
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6929
- }
6930
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6931
- if (!SWIG_IsOK(res1)) {
6932
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fxm", 1, self ));
6933
- }
6934
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6935
- result = (double) ((arg1)->fxm);
6936
- vresult = SWIG_From_double(static_cast< double >(result));
6937
- return vresult;
6938
- fail:
6939
- return Qnil;
6940
- }
6941
-
6942
-
6943
- SWIGINTERN VALUE
6944
- _wrap_LogitMcState_fy_set(int argc, VALUE *argv, VALUE self) {
6945
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6946
- double arg2 ;
6947
- void *argp1 = 0 ;
6948
- int res1 = 0 ;
6949
- double val2 ;
6950
- int ecode2 = 0 ;
6951
-
6952
- if ((argc < 1) || (argc > 1)) {
6953
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6954
- }
6955
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6956
- if (!SWIG_IsOK(res1)) {
6957
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fy", 1, self ));
6958
- }
6959
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6960
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
6961
- if (!SWIG_IsOK(ecode2)) {
6962
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","fy", 2, argv[0] ));
6963
- }
6964
- arg2 = static_cast< double >(val2);
6965
- if (arg1) (arg1)->fy = arg2;
6966
- return Qnil;
6967
- fail:
6968
- return Qnil;
6969
- }
6970
-
6971
-
6972
- SWIGINTERN VALUE
6973
- _wrap_LogitMcState_fy_get(int argc, VALUE *argv, VALUE self) {
6974
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6975
- void *argp1 = 0 ;
6976
- int res1 = 0 ;
6977
- double result;
6978
- VALUE vresult = Qnil;
6979
-
6980
- if ((argc < 0) || (argc > 0)) {
6981
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6982
- }
6983
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
6984
- if (!SWIG_IsOK(res1)) {
6985
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fy", 1, self ));
6986
- }
6987
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
6988
- result = (double) ((arg1)->fy);
6989
- vresult = SWIG_From_double(static_cast< double >(result));
6990
- return vresult;
6991
- fail:
6992
- return Qnil;
6993
- }
6994
-
6995
-
6996
- SWIGINTERN VALUE
6997
- _wrap_LogitMcState_fym_set(int argc, VALUE *argv, VALUE self) {
6998
- logitmcstate *arg1 = (logitmcstate *) 0 ;
6999
- double arg2 ;
7000
- void *argp1 = 0 ;
7001
- int res1 = 0 ;
7002
- double val2 ;
7003
- int ecode2 = 0 ;
7004
-
7005
- if ((argc < 1) || (argc > 1)) {
7006
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7007
- }
7008
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7009
- if (!SWIG_IsOK(res1)) {
7010
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fym", 1, self ));
7011
- }
7012
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7013
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
7014
- if (!SWIG_IsOK(ecode2)) {
7015
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","fym", 2, argv[0] ));
7016
- }
7017
- arg2 = static_cast< double >(val2);
7018
- if (arg1) (arg1)->fym = arg2;
7019
- return Qnil;
7020
- fail:
7021
- return Qnil;
7022
- }
7023
-
7024
-
7025
- SWIGINTERN VALUE
7026
- _wrap_LogitMcState_fym_get(int argc, VALUE *argv, VALUE self) {
7027
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7028
- void *argp1 = 0 ;
7029
- int res1 = 0 ;
7030
- double result;
7031
- VALUE vresult = Qnil;
7032
-
7033
- if ((argc < 0) || (argc > 0)) {
7034
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7035
- }
7036
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7037
- if (!SWIG_IsOK(res1)) {
7038
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","fym", 1, self ));
7039
- }
7040
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7041
- result = (double) ((arg1)->fym);
7042
- vresult = SWIG_From_double(static_cast< double >(result));
7043
- return vresult;
7044
- fail:
7045
- return Qnil;
7046
- }
7047
-
7048
-
7049
- SWIGINTERN VALUE
7050
- _wrap_LogitMcState_stx_set(int argc, VALUE *argv, VALUE self) {
7051
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7052
- double arg2 ;
7053
- void *argp1 = 0 ;
7054
- int res1 = 0 ;
7055
- double val2 ;
7056
- int ecode2 = 0 ;
7057
-
7058
- if ((argc < 1) || (argc > 1)) {
7059
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7060
- }
7061
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7062
- if (!SWIG_IsOK(res1)) {
7063
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stx", 1, self ));
7064
- }
7065
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7066
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
7067
- if (!SWIG_IsOK(ecode2)) {
7068
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","stx", 2, argv[0] ));
7069
- }
7070
- arg2 = static_cast< double >(val2);
7071
- if (arg1) (arg1)->stx = arg2;
7072
- return Qnil;
7073
- fail:
7074
- return Qnil;
7075
- }
7076
-
7077
-
7078
- SWIGINTERN VALUE
7079
- _wrap_LogitMcState_stx_get(int argc, VALUE *argv, VALUE self) {
7080
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7081
- void *argp1 = 0 ;
7082
- int res1 = 0 ;
7083
- double result;
7084
- VALUE vresult = Qnil;
7085
-
7086
- if ((argc < 0) || (argc > 0)) {
7087
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7088
- }
7089
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7090
- if (!SWIG_IsOK(res1)) {
7091
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stx", 1, self ));
7092
- }
7093
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7094
- result = (double) ((arg1)->stx);
7095
- vresult = SWIG_From_double(static_cast< double >(result));
7096
- return vresult;
7097
- fail:
7098
- return Qnil;
7099
- }
7100
-
7101
-
7102
- SWIGINTERN VALUE
7103
- _wrap_LogitMcState_sty_set(int argc, VALUE *argv, VALUE self) {
7104
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7105
- double arg2 ;
7106
- void *argp1 = 0 ;
7107
- int res1 = 0 ;
7108
- double val2 ;
7109
- int ecode2 = 0 ;
7110
-
7111
- if ((argc < 1) || (argc > 1)) {
7112
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7113
- }
7114
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7115
- if (!SWIG_IsOK(res1)) {
7116
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","sty", 1, self ));
7117
- }
7118
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7119
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
7120
- if (!SWIG_IsOK(ecode2)) {
7121
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","sty", 2, argv[0] ));
7122
- }
7123
- arg2 = static_cast< double >(val2);
7124
- if (arg1) (arg1)->sty = arg2;
7125
- return Qnil;
7126
- fail:
7127
- return Qnil;
7128
- }
7129
-
7130
-
7131
- SWIGINTERN VALUE
7132
- _wrap_LogitMcState_sty_get(int argc, VALUE *argv, VALUE self) {
7133
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7134
- void *argp1 = 0 ;
7135
- int res1 = 0 ;
7136
- double result;
7137
- VALUE vresult = Qnil;
7138
-
7139
- if ((argc < 0) || (argc > 0)) {
7140
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7141
- }
7142
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7143
- if (!SWIG_IsOK(res1)) {
7144
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","sty", 1, self ));
7145
- }
7146
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7147
- result = (double) ((arg1)->sty);
7148
- vresult = SWIG_From_double(static_cast< double >(result));
7149
- return vresult;
7150
- fail:
7151
- return Qnil;
7152
- }
7153
-
7154
-
7155
- SWIGINTERN VALUE
7156
- _wrap_LogitMcState_stmin_set(int argc, VALUE *argv, VALUE self) {
7157
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7158
- double arg2 ;
7159
- void *argp1 = 0 ;
7160
- int res1 = 0 ;
7161
- double val2 ;
7162
- int ecode2 = 0 ;
7163
-
7164
- if ((argc < 1) || (argc > 1)) {
7165
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7166
- }
7167
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7168
- if (!SWIG_IsOK(res1)) {
7169
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stmin", 1, self ));
7170
- }
7171
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7172
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
7173
- if (!SWIG_IsOK(ecode2)) {
7174
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","stmin", 2, argv[0] ));
7175
- }
7176
- arg2 = static_cast< double >(val2);
7177
- if (arg1) (arg1)->stmin = arg2;
7178
- return Qnil;
7179
- fail:
7180
- return Qnil;
7181
- }
7182
-
7183
-
7184
- SWIGINTERN VALUE
7185
- _wrap_LogitMcState_stmin_get(int argc, VALUE *argv, VALUE self) {
7186
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7187
- void *argp1 = 0 ;
7188
- int res1 = 0 ;
7189
- double result;
7190
- VALUE vresult = Qnil;
7191
-
7192
- if ((argc < 0) || (argc > 0)) {
7193
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7194
- }
7195
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7196
- if (!SWIG_IsOK(res1)) {
7197
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stmin", 1, self ));
7198
- }
7199
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7200
- result = (double) ((arg1)->stmin);
7201
- vresult = SWIG_From_double(static_cast< double >(result));
7202
- return vresult;
7203
- fail:
7204
- return Qnil;
7205
- }
7206
-
7207
-
7208
- SWIGINTERN VALUE
7209
- _wrap_LogitMcState_stmax_set(int argc, VALUE *argv, VALUE self) {
7210
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7211
- double arg2 ;
7212
- void *argp1 = 0 ;
7213
- int res1 = 0 ;
7214
- double val2 ;
7215
- int ecode2 = 0 ;
7216
-
7217
- if ((argc < 1) || (argc > 1)) {
7218
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7219
- }
7220
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7221
- if (!SWIG_IsOK(res1)) {
7222
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stmax", 1, self ));
7223
- }
7224
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7225
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
7226
- if (!SWIG_IsOK(ecode2)) {
7227
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","stmax", 2, argv[0] ));
7228
- }
7229
- arg2 = static_cast< double >(val2);
7230
- if (arg1) (arg1)->stmax = arg2;
7231
- return Qnil;
7232
- fail:
7233
- return Qnil;
7234
- }
7235
-
7236
-
7237
- SWIGINTERN VALUE
7238
- _wrap_LogitMcState_stmax_get(int argc, VALUE *argv, VALUE self) {
7239
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7240
- void *argp1 = 0 ;
7241
- int res1 = 0 ;
7242
- double result;
7243
- VALUE vresult = Qnil;
7244
-
7245
- if ((argc < 0) || (argc > 0)) {
7246
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7247
- }
7248
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7249
- if (!SWIG_IsOK(res1)) {
7250
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","stmax", 1, self ));
7251
- }
7252
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7253
- result = (double) ((arg1)->stmax);
7254
- vresult = SWIG_From_double(static_cast< double >(result));
7255
- return vresult;
7256
- fail:
7257
- return Qnil;
7258
- }
7259
-
7260
-
7261
- SWIGINTERN VALUE
7262
- _wrap_LogitMcState_width_set(int argc, VALUE *argv, VALUE self) {
7263
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7264
- double arg2 ;
7265
- void *argp1 = 0 ;
7266
- int res1 = 0 ;
7267
- double val2 ;
7268
- int ecode2 = 0 ;
7269
-
7270
- if ((argc < 1) || (argc > 1)) {
7271
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7272
- }
7273
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7274
- if (!SWIG_IsOK(res1)) {
7275
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","width", 1, self ));
7276
- }
7277
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7278
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
7279
- if (!SWIG_IsOK(ecode2)) {
7280
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","width", 2, argv[0] ));
7281
- }
7282
- arg2 = static_cast< double >(val2);
7283
- if (arg1) (arg1)->width = arg2;
7284
- return Qnil;
7285
- fail:
7286
- return Qnil;
7287
- }
7288
-
7289
-
7290
- SWIGINTERN VALUE
7291
- _wrap_LogitMcState_width_get(int argc, VALUE *argv, VALUE self) {
7292
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7293
- void *argp1 = 0 ;
7294
- int res1 = 0 ;
7295
- double result;
7296
- VALUE vresult = Qnil;
7297
-
7298
- if ((argc < 0) || (argc > 0)) {
7299
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7300
- }
7301
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7302
- if (!SWIG_IsOK(res1)) {
7303
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","width", 1, self ));
7304
- }
7305
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7306
- result = (double) ((arg1)->width);
7307
- vresult = SWIG_From_double(static_cast< double >(result));
7308
- return vresult;
7309
- fail:
7310
- return Qnil;
7311
- }
7312
-
7313
-
7314
- SWIGINTERN VALUE
7315
- _wrap_LogitMcState_width1_set(int argc, VALUE *argv, VALUE self) {
7316
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7317
- double arg2 ;
7318
- void *argp1 = 0 ;
7319
- int res1 = 0 ;
7320
- double val2 ;
7321
- int ecode2 = 0 ;
7322
-
7323
- if ((argc < 1) || (argc > 1)) {
7324
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7325
- }
7326
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7327
- if (!SWIG_IsOK(res1)) {
7328
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","width1", 1, self ));
7329
- }
7330
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7331
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
7332
- if (!SWIG_IsOK(ecode2)) {
7333
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","width1", 2, argv[0] ));
7334
- }
7335
- arg2 = static_cast< double >(val2);
7336
- if (arg1) (arg1)->width1 = arg2;
7337
- return Qnil;
7338
- fail:
7339
- return Qnil;
7340
- }
7341
-
7342
-
7343
- SWIGINTERN VALUE
7344
- _wrap_LogitMcState_width1_get(int argc, VALUE *argv, VALUE self) {
7345
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7346
- void *argp1 = 0 ;
7347
- int res1 = 0 ;
7348
- double result;
7349
- VALUE vresult = Qnil;
7350
-
7351
- if ((argc < 0) || (argc > 0)) {
7352
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7353
- }
7354
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7355
- if (!SWIG_IsOK(res1)) {
7356
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","width1", 1, self ));
7357
- }
7358
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7359
- result = (double) ((arg1)->width1);
7360
- vresult = SWIG_From_double(static_cast< double >(result));
7361
- return vresult;
7362
- fail:
7363
- return Qnil;
7364
- }
7365
-
7366
-
7367
- SWIGINTERN VALUE
7368
- _wrap_LogitMcState_xtrapf_set(int argc, VALUE *argv, VALUE self) {
7369
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7370
- double arg2 ;
7371
- void *argp1 = 0 ;
7372
- int res1 = 0 ;
7373
- double val2 ;
7374
- int ecode2 = 0 ;
7375
-
7376
- if ((argc < 1) || (argc > 1)) {
7377
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7378
- }
7379
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7380
- if (!SWIG_IsOK(res1)) {
7381
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","xtrapf", 1, self ));
7382
- }
7383
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7384
- ecode2 = SWIG_AsVal_double(argv[0], &val2);
7385
- if (!SWIG_IsOK(ecode2)) {
7386
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","xtrapf", 2, argv[0] ));
7387
- }
7388
- arg2 = static_cast< double >(val2);
7389
- if (arg1) (arg1)->xtrapf = arg2;
7390
- return Qnil;
7391
- fail:
7392
- return Qnil;
7393
- }
7394
-
7395
-
7396
- SWIGINTERN VALUE
7397
- _wrap_LogitMcState_xtrapf_get(int argc, VALUE *argv, VALUE self) {
7398
- logitmcstate *arg1 = (logitmcstate *) 0 ;
7399
- void *argp1 = 0 ;
7400
- int res1 = 0 ;
7401
- double result;
7402
- VALUE vresult = Qnil;
7403
-
7404
- if ((argc < 0) || (argc > 0)) {
7405
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7406
- }
7407
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_logitmcstate, 0 | 0 );
7408
- if (!SWIG_IsOK(res1)) {
7409
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmcstate *","xtrapf", 1, self ));
7410
- }
7411
- arg1 = reinterpret_cast< logitmcstate * >(argp1);
7412
- result = (double) ((arg1)->xtrapf);
7413
- vresult = SWIG_From_double(static_cast< double >(result));
7414
- return vresult;
7415
- fail:
7416
- return Qnil;
7417
- }
7418
-
7419
-
7420
- #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
7421
- SWIGINTERN VALUE
7422
- _wrap_LogitMcState_allocate(VALUE self) {
7423
- #else
7424
- SWIGINTERN VALUE
7425
- _wrap_LogitMcState_allocate(int argc, VALUE *argv, VALUE self) {
7426
- #endif
7427
-
7428
-
7429
- VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_logitmcstate);
7430
- #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
7431
- rb_obj_call_init(vresult, argc, argv);
7432
- #endif
7433
- return vresult;
7434
- }
7435
-
7436
-
7437
- SWIGINTERN VALUE
7438
- _wrap_new_LogitMcState(int argc, VALUE *argv, VALUE self) {
7439
- logitmcstate *result = 0 ;
7440
-
7441
- if ((argc < 0) || (argc > 0)) {
7442
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7443
- }
7444
- result = (logitmcstate *)new logitmcstate();
7445
- DATA_PTR(self) = result;
7446
- return self;
7447
- fail:
7448
- return Qnil;
7449
- }
7450
-
7451
-
7452
- SWIGINTERN void
7453
- free_logitmcstate(logitmcstate *arg1) {
7454
- delete arg1;
7455
- }
7456
-
7457
- swig_class cMNLReport;
7458
-
7459
- SWIGINTERN VALUE
7460
- _wrap_MNLReport_ngrad_set(int argc, VALUE *argv, VALUE self) {
7461
- mnlreport *arg1 = (mnlreport *) 0 ;
7462
- int arg2 ;
7463
- void *argp1 = 0 ;
7464
- int res1 = 0 ;
7465
- int val2 ;
7466
- int ecode2 = 0 ;
7467
-
7468
- if ((argc < 1) || (argc > 1)) {
7469
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7470
- }
7471
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mnlreport, 0 | 0 );
7472
- if (!SWIG_IsOK(res1)) {
7473
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mnlreport *","ngrad", 1, self ));
7474
- }
7475
- arg1 = reinterpret_cast< mnlreport * >(argp1);
7476
- ecode2 = SWIG_AsVal_int(argv[0], &val2);
7477
- if (!SWIG_IsOK(ecode2)) {
7478
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","ngrad", 2, argv[0] ));
7479
- }
7480
- arg2 = static_cast< int >(val2);
7481
- if (arg1) (arg1)->ngrad = arg2;
7482
- return Qnil;
7483
- fail:
7484
- return Qnil;
7485
- }
7486
-
7487
-
7488
- SWIGINTERN VALUE
7489
- _wrap_MNLReport_ngrad_get(int argc, VALUE *argv, VALUE self) {
7490
- mnlreport *arg1 = (mnlreport *) 0 ;
7491
- void *argp1 = 0 ;
7492
- int res1 = 0 ;
7493
- int result;
7494
- VALUE vresult = Qnil;
7495
-
7496
- if ((argc < 0) || (argc > 0)) {
7497
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7498
- }
7499
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mnlreport, 0 | 0 );
7500
- if (!SWIG_IsOK(res1)) {
7501
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mnlreport *","ngrad", 1, self ));
7502
- }
7503
- arg1 = reinterpret_cast< mnlreport * >(argp1);
7504
- result = (int) ((arg1)->ngrad);
7505
- vresult = SWIG_From_int(static_cast< int >(result));
7506
- return vresult;
7507
- fail:
7508
- return Qnil;
7509
- }
7510
-
7511
-
7512
- SWIGINTERN VALUE
7513
- _wrap_MNLReport_nhess_set(int argc, VALUE *argv, VALUE self) {
7514
- mnlreport *arg1 = (mnlreport *) 0 ;
7515
- int arg2 ;
7516
- void *argp1 = 0 ;
7517
- int res1 = 0 ;
7518
- int val2 ;
7519
- int ecode2 = 0 ;
7520
-
7521
- if ((argc < 1) || (argc > 1)) {
7522
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7523
- }
7524
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mnlreport, 0 | 0 );
7525
- if (!SWIG_IsOK(res1)) {
7526
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mnlreport *","nhess", 1, self ));
7527
- }
7528
- arg1 = reinterpret_cast< mnlreport * >(argp1);
7529
- ecode2 = SWIG_AsVal_int(argv[0], &val2);
7530
- if (!SWIG_IsOK(ecode2)) {
7531
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","nhess", 2, argv[0] ));
7532
- }
7533
- arg2 = static_cast< int >(val2);
7534
- if (arg1) (arg1)->nhess = arg2;
7535
- return Qnil;
7536
- fail:
7537
- return Qnil;
7538
- }
7539
-
7540
-
7541
- SWIGINTERN VALUE
7542
- _wrap_MNLReport_nhess_get(int argc, VALUE *argv, VALUE self) {
7543
- mnlreport *arg1 = (mnlreport *) 0 ;
7544
- void *argp1 = 0 ;
7545
- int res1 = 0 ;
7546
- int result;
7547
- VALUE vresult = Qnil;
7548
-
7549
- if ((argc < 0) || (argc > 0)) {
7550
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7551
- }
7552
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mnlreport, 0 | 0 );
7553
- if (!SWIG_IsOK(res1)) {
7554
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mnlreport *","nhess", 1, self ));
7555
- }
7556
- arg1 = reinterpret_cast< mnlreport * >(argp1);
7557
- result = (int) ((arg1)->nhess);
7558
- vresult = SWIG_From_int(static_cast< int >(result));
7559
- return vresult;
7560
- fail:
7561
- return Qnil;
7562
- }
7563
-
7564
-
7565
- #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
7566
- SWIGINTERN VALUE
7567
- _wrap_MNLReport_allocate(VALUE self) {
7568
- #else
7569
- SWIGINTERN VALUE
7570
- _wrap_MNLReport_allocate(int argc, VALUE *argv, VALUE self) {
7571
- #endif
7572
-
7573
-
7574
- VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_mnlreport);
7575
- #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
7576
- rb_obj_call_init(vresult, argc, argv);
7577
- #endif
7578
- return vresult;
7579
- }
7580
-
7581
-
7582
- SWIGINTERN VALUE
7583
- _wrap_new_MNLReport(int argc, VALUE *argv, VALUE self) {
7584
- mnlreport *result = 0 ;
7585
-
7586
- if ((argc < 0) || (argc > 0)) {
7587
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7588
- }
7589
- result = (mnlreport *)new mnlreport();
7590
- DATA_PTR(self) = result;
7591
- return self;
7592
- fail:
7593
- return Qnil;
7594
- }
7595
-
7596
-
7597
- SWIGINTERN void
7598
- free_mnlreport(mnlreport *arg1) {
7599
- delete arg1;
7600
- }
7601
-
7602
- SWIGINTERN VALUE
7603
- _wrap_mnltrainh(int argc, VALUE *argv, VALUE self) {
7604
- ap::real_2d_array *arg1 = 0 ;
7605
- int arg2 ;
7606
- int arg3 ;
7607
- int arg4 ;
7608
- int *arg5 = 0 ;
7609
- logitmodel *arg6 = 0 ;
7610
- mnlreport *arg7 = 0 ;
7611
- void *argp1 ;
7612
- int res1 = 0 ;
7613
- int val2 ;
7614
- int ecode2 = 0 ;
7615
- int val3 ;
7616
- int ecode3 = 0 ;
7617
- int val4 ;
7618
- int ecode4 = 0 ;
7619
- int temp5 ;
7620
- int res5 = SWIG_TMPOBJ ;
7621
- void *argp6 = 0 ;
7622
- int res6 = 0 ;
7623
- void *argp7 = 0 ;
7624
- int res7 = 0 ;
7625
- VALUE vresult = Qnil;
7626
-
7627
- arg5 = &temp5;
7628
- if ((argc < 6) || (argc > 6)) {
7629
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
7630
- }
7631
- res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_ap__template_2d_arrayT_double_true_t, 0 );
7632
- if (!SWIG_IsOK(res1)) {
7633
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ap::real_2d_array const &","mnltrainh", 1, argv[0] ));
7634
- }
7635
- if (!argp1) {
7636
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::real_2d_array const &","mnltrainh", 1, argv[0]));
7637
- }
7638
- arg1 = reinterpret_cast< ap::real_2d_array * >(argp1);
7639
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
7640
- if (!SWIG_IsOK(ecode2)) {
7641
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","mnltrainh", 2, argv[1] ));
7642
- }
7643
- arg2 = static_cast< int >(val2);
7644
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
7645
- if (!SWIG_IsOK(ecode3)) {
7646
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","mnltrainh", 3, argv[2] ));
7647
- }
7648
- arg3 = static_cast< int >(val3);
7649
- ecode4 = SWIG_AsVal_int(argv[3], &val4);
7650
- if (!SWIG_IsOK(ecode4)) {
7651
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","mnltrainh", 4, argv[3] ));
7652
- }
7653
- arg4 = static_cast< int >(val4);
7654
- res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_logitmodel, 0 );
7655
- if (!SWIG_IsOK(res6)) {
7656
- SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "logitmodel &","mnltrainh", 6, argv[4] ));
7657
- }
7658
- if (!argp6) {
7659
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel &","mnltrainh", 6, argv[4]));
7660
- }
7661
- arg6 = reinterpret_cast< logitmodel * >(argp6);
7662
- res7 = SWIG_ConvertPtr(argv[5], &argp7, SWIGTYPE_p_mnlreport, 0 );
7663
- if (!SWIG_IsOK(res7)) {
7664
- SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "mnlreport &","mnltrainh", 7, argv[5] ));
7665
- }
7666
- if (!argp7) {
7667
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "mnlreport &","mnltrainh", 7, argv[5]));
7668
- }
7669
- arg7 = reinterpret_cast< mnlreport * >(argp7);
7670
- mnltrainh((ap::template_2d_array< double,true > const &)*arg1,arg2,arg3,arg4,*arg5,*arg6,*arg7);
7671
- if (SWIG_IsTmpObj(res5)) {
7672
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg5)));
7673
- } else {
7674
- int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7675
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
7676
- }
7677
- return vresult;
7678
- fail:
7679
- return Qnil;
7680
- }
7681
-
7682
-
7683
- SWIGINTERN VALUE
7684
- _wrap_mnlprocess(int argc, VALUE *argv, VALUE self) {
7685
- logitmodel *arg1 = 0 ;
7686
- ap::real_1d_array *arg2 = 0 ;
7687
- void *argp1 = 0 ;
7688
- int res1 = 0 ;
7689
- VALUE result;
7690
- VALUE vresult = Qnil;
7691
-
7692
- if ((argc < 2) || (argc > 2)) {
7693
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
7694
- }
7695
- res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_logitmodel, 0 );
7696
- if (!SWIG_IsOK(res1)) {
7697
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmodel &","wrap_mnlprocess", 1, argv[0] ));
7698
- }
7699
- if (!argp1) {
7700
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel &","wrap_mnlprocess", 1, argv[0]));
7701
- }
7702
- arg1 = reinterpret_cast< logitmodel * >(argp1);
7703
- {
7704
- arg2 = new ap::real_1d_array();
7705
- arg2->setlength(RARRAY_LEN(argv[1]));
7706
- for(long i=0;i<RARRAY_LEN(argv[1]);i++) {
7707
- arg2->operator()(i)=rb_num2dbl(RARRAY_PTR(argv[1])[i]);
7708
- }
7709
- }
7710
- result = (VALUE)wrap_mnlprocess(*arg1,(ap::template_1d_array< double,true > const &)*arg2);
7711
- vresult = result;
7712
- return vresult;
7713
- fail:
7714
- return Qnil;
7715
- }
7716
-
7717
-
7718
- SWIGINTERN VALUE
7719
- _wrap_mnlunpack(int argc, VALUE *argv, VALUE self) {
7720
- logitmodel *arg1 = 0 ;
7721
- ap::real_2d_array *arg2 = 0 ;
7722
- int *arg3 = 0 ;
7723
- int *arg4 = 0 ;
7724
- void *argp1 ;
7725
- int res1 = 0 ;
7726
- void *argp2 = 0 ;
7727
- int res2 = 0 ;
7728
- int temp3 ;
7729
- int res3 = 0 ;
7730
- int temp4 ;
7731
- int res4 = 0 ;
7732
-
7733
- if ((argc < 4) || (argc > 4)) {
7734
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
7735
- }
7736
- res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_logitmodel, 0 );
7737
- if (!SWIG_IsOK(res1)) {
7738
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmodel const &","mnlunpack", 1, argv[0] ));
7739
- }
7740
- if (!argp1) {
7741
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel const &","mnlunpack", 1, argv[0]));
7742
- }
7743
- arg1 = reinterpret_cast< logitmodel * >(argp1);
7744
- res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_ap__template_2d_arrayT_double_true_t, 0 );
7745
- if (!SWIG_IsOK(res2)) {
7746
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "ap::real_2d_array &","mnlunpack", 2, argv[1] ));
7747
- }
7748
- if (!argp2) {
7749
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::real_2d_array &","mnlunpack", 2, argv[1]));
7750
- }
7751
- arg2 = reinterpret_cast< ap::real_2d_array * >(argp2);
7752
- if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
7753
- int val;
7754
- int ecode = SWIG_AsVal_int(argv[2], &val);
7755
- if (!SWIG_IsOK(ecode)) {
7756
- SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "int","mnlunpack", 3, argv[2] ));
7757
- }
7758
- temp3 = static_cast< int >(val);
7759
- arg3 = &temp3;
7760
- res3 = SWIG_AddTmpMask(ecode);
7761
- }
7762
- if (!(SWIG_IsOK((res4 = SWIG_ConvertPtr(argv[3],SWIG_as_voidptrptr(&arg4),SWIGTYPE_p_int,0))))) {
7763
- int val;
7764
- int ecode = SWIG_AsVal_int(argv[3], &val);
7765
- if (!SWIG_IsOK(ecode)) {
7766
- SWIG_exception_fail(SWIG_ArgError(ecode), Ruby_Format_TypeError( "", "int","mnlunpack", 4, argv[3] ));
7767
- }
7768
- temp4 = static_cast< int >(val);
7769
- arg4 = &temp4;
7770
- res4 = SWIG_AddTmpMask(ecode);
7771
- }
7772
- mnlunpack((logitmodel const &)*arg1,*arg2,*arg3,*arg4);
7773
- if (SWIG_IsNewObj(res3)) delete arg3;
7774
- if (SWIG_IsNewObj(res4)) delete arg4;
7775
- return Qnil;
7776
- fail:
7777
- if (SWIG_IsNewObj(res3)) delete arg3;
7778
- if (SWIG_IsNewObj(res4)) delete arg4;
7779
- return Qnil;
7780
- }
7781
-
7782
-
7783
- SWIGINTERN VALUE
7784
- _wrap_mnlpack(int argc, VALUE *argv, VALUE self) {
7785
- ap::real_2d_array *arg1 = 0 ;
7786
- int arg2 ;
7787
- int arg3 ;
7788
- logitmodel *arg4 = 0 ;
7789
- void *argp1 ;
7790
- int res1 = 0 ;
7791
- int val2 ;
7792
- int ecode2 = 0 ;
7793
- int val3 ;
7794
- int ecode3 = 0 ;
7795
- void *argp4 = 0 ;
7796
- int res4 = 0 ;
7797
-
7798
- if ((argc < 4) || (argc > 4)) {
7799
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
7800
- }
7801
- res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_ap__template_2d_arrayT_double_true_t, 0 );
7802
- if (!SWIG_IsOK(res1)) {
7803
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ap::real_2d_array const &","mnlpack", 1, argv[0] ));
7804
- }
7805
- if (!argp1) {
7806
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::real_2d_array const &","mnlpack", 1, argv[0]));
7807
- }
7808
- arg1 = reinterpret_cast< ap::real_2d_array * >(argp1);
7809
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
7810
- if (!SWIG_IsOK(ecode2)) {
7811
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","mnlpack", 2, argv[1] ));
7812
- }
7813
- arg2 = static_cast< int >(val2);
7814
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
7815
- if (!SWIG_IsOK(ecode3)) {
7816
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","mnlpack", 3, argv[2] ));
7817
- }
7818
- arg3 = static_cast< int >(val3);
7819
- res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_logitmodel, 0 );
7820
- if (!SWIG_IsOK(res4)) {
7821
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "logitmodel &","mnlpack", 4, argv[3] ));
7822
- }
7823
- if (!argp4) {
7824
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel &","mnlpack", 4, argv[3]));
7825
- }
7826
- arg4 = reinterpret_cast< logitmodel * >(argp4);
7827
- mnlpack((ap::template_2d_array< double,true > const &)*arg1,arg2,arg3,*arg4);
7828
- return Qnil;
7829
- fail:
7830
- return Qnil;
7831
- }
7832
-
7833
-
7834
- SWIGINTERN VALUE
7835
- _wrap_mnlserialize(int argc, VALUE *argv, VALUE self) {
7836
- logitmodel *arg1 = 0 ;
7837
- ap::real_1d_array *arg2 = 0 ;
7838
- int *arg3 = 0 ;
7839
- void *argp1 ;
7840
- int res1 = 0 ;
7841
- void *argp2 = 0 ;
7842
- int res2 = 0 ;
7843
- void *argp3 = 0 ;
7844
- int res3 = 0 ;
7845
-
7846
- if ((argc < 3) || (argc > 3)) {
7847
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
7848
- }
7849
- res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_logitmodel, 0 );
7850
- if (!SWIG_IsOK(res1)) {
7851
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmodel const &","mnlserialize", 1, argv[0] ));
7852
- }
7853
- if (!argp1) {
7854
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel const &","mnlserialize", 1, argv[0]));
7855
- }
7856
- arg1 = reinterpret_cast< logitmodel * >(argp1);
7857
- res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 );
7858
- if (!SWIG_IsOK(res2)) {
7859
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "ap::real_1d_array &","mnlserialize", 2, argv[1] ));
7860
- }
7861
- if (!argp2) {
7862
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::real_1d_array &","mnlserialize", 2, argv[1]));
7863
- }
7864
- arg2 = reinterpret_cast< ap::real_1d_array * >(argp2);
7865
- res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_int, 0 );
7866
- if (!SWIG_IsOK(res3)) {
7867
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int &","mnlserialize", 3, argv[2] ));
7868
- }
7869
- if (!argp3) {
7870
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int &","mnlserialize", 3, argv[2]));
7871
- }
7872
- arg3 = reinterpret_cast< int * >(argp3);
7873
- mnlserialize((logitmodel const &)*arg1,*arg2,*arg3);
7874
- return Qnil;
7875
- fail:
7876
- return Qnil;
7877
- }
7878
-
7879
-
7880
- SWIGINTERN VALUE
7881
- _wrap_mnlcopy(int argc, VALUE *argv, VALUE self) {
7882
- logitmodel *arg1 = 0 ;
7883
- logitmodel *arg2 = 0 ;
7884
- void *argp1 ;
7885
- int res1 = 0 ;
7886
- void *argp2 = 0 ;
7887
- int res2 = 0 ;
7888
-
7889
- if ((argc < 2) || (argc > 2)) {
7890
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
7891
- }
7892
- res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_logitmodel, 0 );
7893
- if (!SWIG_IsOK(res1)) {
7894
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmodel const &","mnlcopy", 1, argv[0] ));
7895
- }
7896
- if (!argp1) {
7897
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel const &","mnlcopy", 1, argv[0]));
7898
- }
7899
- arg1 = reinterpret_cast< logitmodel * >(argp1);
7900
- res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_logitmodel, 0 );
7901
- if (!SWIG_IsOK(res2)) {
7902
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "logitmodel &","mnlcopy", 2, argv[1] ));
7903
- }
7904
- if (!argp2) {
7905
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel &","mnlcopy", 2, argv[1]));
7906
- }
7907
- arg2 = reinterpret_cast< logitmodel * >(argp2);
7908
- mnlcopy((logitmodel const &)*arg1,*arg2);
7909
- return Qnil;
7910
- fail:
7911
- return Qnil;
7912
- }
7913
-
7914
-
7915
- SWIGINTERN VALUE
7916
- _wrap_mnlunserialize(int argc, VALUE *argv, VALUE self) {
7917
- ap::real_1d_array *arg1 = 0 ;
7918
- logitmodel *arg2 = 0 ;
7919
- void *argp2 = 0 ;
7920
- int res2 = 0 ;
7921
-
7922
- if ((argc < 2) || (argc > 2)) {
7923
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
7924
- }
7925
- {
7926
- arg1 = new ap::real_1d_array();
7927
- arg1->setlength(RARRAY_LEN(argv[0]));
7928
- for(long i=0;i<RARRAY_LEN(argv[0]);i++) {
7929
- arg1->operator()(i)=rb_num2dbl(RARRAY_PTR(argv[0])[i]);
7930
- }
7931
- }
7932
- res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_logitmodel, 0 );
7933
- if (!SWIG_IsOK(res2)) {
7934
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "logitmodel &","mnlunserialize", 2, argv[1] ));
7935
- }
7936
- if (!argp2) {
7937
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel &","mnlunserialize", 2, argv[1]));
7938
- }
7939
- arg2 = reinterpret_cast< logitmodel * >(argp2);
7940
- mnlunserialize((ap::template_1d_array< double,true > const &)*arg1,*arg2);
7941
- return Qnil;
7942
- fail:
7943
- return Qnil;
7944
- }
7945
-
7946
-
7947
- SWIGINTERN VALUE
7948
- _wrap_mnlavgce(int argc, VALUE *argv, VALUE self) {
7949
- logitmodel *arg1 = 0 ;
7950
- ap::real_2d_array *arg2 = 0 ;
7951
- int arg3 ;
7952
- void *argp1 = 0 ;
7953
- int res1 = 0 ;
7954
- void *argp2 ;
7955
- int res2 = 0 ;
7956
- int val3 ;
7957
- int ecode3 = 0 ;
7958
- double result;
7959
- VALUE vresult = Qnil;
7960
-
7961
- if ((argc < 3) || (argc > 3)) {
7962
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
7963
- }
7964
- res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_logitmodel, 0 );
7965
- if (!SWIG_IsOK(res1)) {
7966
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "logitmodel &","mnlavgce", 1, argv[0] ));
7967
- }
7968
- if (!argp1) {
7969
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "logitmodel &","mnlavgce", 1, argv[0]));
7970
- }
7971
- arg1 = reinterpret_cast< logitmodel * >(argp1);
7972
- res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_ap__template_2d_arrayT_double_true_t, 0 );
7973
- if (!SWIG_IsOK(res2)) {
7974
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "ap::real_2d_array const &","mnlavgce", 2, argv[1] ));
7975
- }
7976
- if (!argp2) {
7977
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::real_2d_array const &","mnlavgce", 2, argv[1]));
7978
- }
7979
- arg2 = reinterpret_cast< ap::real_2d_array * >(argp2);
7980
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
7981
- if (!SWIG_IsOK(ecode3)) {
7982
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","mnlavgce", 3, argv[2] ));
7983
- }
7984
- arg3 = static_cast< int >(val3);
7985
- result = (double)mnlavgce(*arg1,(ap::template_2d_array< double,true > const &)*arg2,arg3);
7986
- vresult = SWIG_From_double(static_cast< double >(result));
7987
- return vresult;
7988
- fail:
7989
- return Qnil;
7990
- }
7991
-
7992
-
7993
- SWIGINTERN VALUE
7994
- _wrap_pcabuildbasis(int argc, VALUE *argv, VALUE self) {
7995
- ap::real_2d_array *arg1 = 0 ;
7996
- int arg2 ;
7997
- int arg3 ;
7998
- int *arg4 = 0 ;
7999
- ap::real_1d_array *arg5 = 0 ;
8000
- ap::real_2d_array *arg6 = 0 ;
8001
- void *argp1 ;
8002
- int res1 = 0 ;
8003
- int val2 ;
8004
- int ecode2 = 0 ;
8005
- int val3 ;
8006
- int ecode3 = 0 ;
8007
- int temp4 ;
8008
- int res4 = SWIG_TMPOBJ ;
8009
- void *argp5 = 0 ;
8010
- int res5 = 0 ;
8011
- void *argp6 = 0 ;
8012
- int res6 = 0 ;
8013
- VALUE vresult = Qnil;
8014
-
8015
- arg4 = &temp4;
8016
- if ((argc < 5) || (argc > 5)) {
8017
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
8018
- }
8019
- res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_ap__template_2d_arrayT_double_true_t, 0 );
8020
- if (!SWIG_IsOK(res1)) {
8021
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ap::real_2d_array const &","pcabuildbasis", 1, argv[0] ));
8022
- }
8023
- if (!argp1) {
8024
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::real_2d_array const &","pcabuildbasis", 1, argv[0]));
8025
- }
8026
- arg1 = reinterpret_cast< ap::real_2d_array * >(argp1);
8027
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
8028
- if (!SWIG_IsOK(ecode2)) {
8029
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pcabuildbasis", 2, argv[1] ));
8030
- }
8031
- arg2 = static_cast< int >(val2);
8032
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
8033
- if (!SWIG_IsOK(ecode3)) {
8034
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","pcabuildbasis", 3, argv[2] ));
8035
- }
8036
- arg3 = static_cast< int >(val3);
8037
- res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_ap__template_1d_arrayT_double_true_t, 0 );
8038
- if (!SWIG_IsOK(res5)) {
8039
- SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "ap::real_1d_array &","pcabuildbasis", 5, argv[3] ));
8040
- }
8041
- if (!argp5) {
8042
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::real_1d_array &","pcabuildbasis", 5, argv[3]));
8043
- }
8044
- arg5 = reinterpret_cast< ap::real_1d_array * >(argp5);
8045
- res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_ap__template_2d_arrayT_double_true_t, 0 );
8046
- if (!SWIG_IsOK(res6)) {
8047
- SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "ap::real_2d_array &","pcabuildbasis", 6, argv[4] ));
8048
- }
8049
- if (!argp6) {
8050
- SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ap::real_2d_array &","pcabuildbasis", 6, argv[4]));
8051
- }
8052
- arg6 = reinterpret_cast< ap::real_2d_array * >(argp6);
8053
- pcabuildbasis((ap::template_2d_array< double,true > const &)*arg1,arg2,arg3,*arg4,*arg5,*arg6);
8054
- if (SWIG_IsTmpObj(res4)) {
8055
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_From_int((*arg4)));
8056
- } else {
8057
- int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8058
- vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
8059
- }
8060
- return vresult;
8061
- fail:
8062
- return Qnil;
8063
- }
8064
-
8065
-
8066
-
8067
- /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5674
+ /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
8068
5675
 
8069
5676
  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};
8070
5677
  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};
@@ -8079,10 +5686,7 @@ static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
8079
5686
  static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
8080
5687
  static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
8081
5688
  static swig_type_info _swigt__p_linearmodel = {"_p_linearmodel", "linearmodel *", 0, 0, (void*)0, 0};
8082
- static swig_type_info _swigt__p_logitmcstate = {"_p_logitmcstate", "logitmcstate *", 0, 0, (void*)0, 0};
8083
- static swig_type_info _swigt__p_logitmodel = {"_p_logitmodel", "logitmodel *", 0, 0, (void*)0, 0};
8084
5689
  static swig_type_info _swigt__p_lrreport = {"_p_lrreport", "lrreport *", 0, 0, (void*)0, 0};
8085
- static swig_type_info _swigt__p_mnlreport = {"_p_mnlreport", "mnlreport *", 0, 0, (void*)0, 0};
8086
5690
 
8087
5691
  static swig_type_info *swig_type_initial[] = {
8088
5692
  &_swigt__p_ap__template_1d_arrayT_bool_false_t,
@@ -8098,10 +5702,7 @@ static swig_type_info *swig_type_initial[] = {
8098
5702
  &_swigt__p_double,
8099
5703
  &_swigt__p_int,
8100
5704
  &_swigt__p_linearmodel,
8101
- &_swigt__p_logitmcstate,
8102
- &_swigt__p_logitmodel,
8103
5705
  &_swigt__p_lrreport,
8104
- &_swigt__p_mnlreport,
8105
5706
  };
8106
5707
 
8107
5708
  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}};
@@ -8117,10 +5718,7 @@ static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0,
8117
5718
  static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
8118
5719
  static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
8119
5720
  static swig_cast_info _swigc__p_linearmodel[] = { {&_swigt__p_linearmodel, 0, 0, 0},{0, 0, 0, 0}};
8120
- static swig_cast_info _swigc__p_logitmcstate[] = { {&_swigt__p_logitmcstate, 0, 0, 0},{0, 0, 0, 0}};
8121
- static swig_cast_info _swigc__p_logitmodel[] = { {&_swigt__p_logitmodel, 0, 0, 0},{0, 0, 0, 0}};
8122
5721
  static swig_cast_info _swigc__p_lrreport[] = { {&_swigt__p_lrreport, 0, 0, 0},{0, 0, 0, 0}};
8123
- static swig_cast_info _swigc__p_mnlreport[] = { {&_swigt__p_mnlreport, 0, 0, 0},{0, 0, 0, 0}};
8124
5722
 
8125
5723
  static swig_cast_info *swig_cast_initial[] = {
8126
5724
  _swigc__p_ap__template_1d_arrayT_bool_false_t,
@@ -8136,10 +5734,7 @@ static swig_cast_info *swig_cast_initial[] = {
8136
5734
  _swigc__p_double,
8137
5735
  _swigc__p_int,
8138
5736
  _swigc__p_linearmodel,
8139
- _swigc__p_logitmcstate,
8140
- _swigc__p_logitmodel,
8141
5737
  _swigc__p_lrreport,
8142
- _swigc__p_mnlreport,
8143
5738
  };
8144
5739
 
8145
5740
 
@@ -8483,12 +6078,6 @@ SWIGEXPORT void Init_alglib_ext(void) {
8483
6078
  cReal2dArray.mark = 0;
8484
6079
  cReal2dArray.destroy = (void (*)(void *)) free_ap_template_2d_array_Sl_double_Sc_true_Sg_;
8485
6080
  cReal2dArray.trackObjects = 0;
8486
- rb_define_module_function(mAlglib_ext, "real1d_to_array", VALUEFUNC(_wrap_real1d_to_array), -1);
8487
- rb_define_module_function(mAlglib_ext, "array_to_real1d", VALUEFUNC(_wrap_array_to_real1d), -1);
8488
- rb_define_module_function(mAlglib_ext, "pearsoncorrelation", VALUEFUNC(_wrap_pearsoncorrelation), -1);
8489
- rb_define_module_function(mAlglib_ext, "spearmanrankcorrelation", VALUEFUNC(_wrap_spearmanrankcorrelation), -1);
8490
- rb_define_module_function(mAlglib_ext, "pearsoncorrelationsignificance", VALUEFUNC(_wrap_pearsoncorrelationsignificance), -1);
8491
- rb_define_module_function(mAlglib_ext, "spearmanrankcorrelationsignificance", VALUEFUNC(_wrap_spearmanrankcorrelationsignificance), -1);
8492
6081
 
8493
6082
  cLinearModel.klass = rb_define_class_under(mAlglib_ext, "LinearModel", rb_cObject);
8494
6083
  SWIG_TypeClientData(SWIGTYPE_p_linearmodel, (void *) &cLinearModel);
@@ -8532,95 +6121,6 @@ SWIGEXPORT void Init_alglib_ext(void) {
8532
6121
  rb_define_module_function(mAlglib_ext, "lrunpack", VALUEFUNC(_wrap_lrunpack), -1);
8533
6122
  rb_define_module_function(mAlglib_ext, "lrpack", VALUEFUNC(_wrap_lrpack), -1);
8534
6123
  rb_define_module_function(mAlglib_ext, "lrprocess", VALUEFUNC(_wrap_lrprocess), -1);
8535
- rb_define_module_function(mAlglib_ext, "mannwhitneyutest", VALUEFUNC(_wrap_mannwhitneyutest), -1);
8536
-
8537
- cLogitModel.klass = rb_define_class_under(mAlglib_ext, "LogitModel", rb_cObject);
8538
- SWIG_TypeClientData(SWIGTYPE_p_logitmodel, (void *) &cLogitModel);
8539
- rb_define_alloc_func(cLogitModel.klass, _wrap_LogitModel_allocate);
8540
- rb_define_method(cLogitModel.klass, "initialize", VALUEFUNC(_wrap_new_LogitModel), -1);
8541
- rb_define_method(cLogitModel.klass, "w=", VALUEFUNC(_wrap_LogitModel_w_set), -1);
8542
- rb_define_method(cLogitModel.klass, "w", VALUEFUNC(_wrap_LogitModel_w_get), -1);
8543
- cLogitModel.mark = 0;
8544
- cLogitModel.destroy = (void (*)(void *)) free_logitmodel;
8545
- cLogitModel.trackObjects = 0;
8546
-
8547
- cLogitMcState.klass = rb_define_class_under(mAlglib_ext, "LogitMcState", rb_cObject);
8548
- SWIG_TypeClientData(SWIGTYPE_p_logitmcstate, (void *) &cLogitMcState);
8549
- rb_define_alloc_func(cLogitMcState.klass, _wrap_LogitMcState_allocate);
8550
- rb_define_method(cLogitMcState.klass, "initialize", VALUEFUNC(_wrap_new_LogitMcState), -1);
8551
- rb_define_method(cLogitMcState.klass, "brackt=", VALUEFUNC(_wrap_LogitMcState_brackt_set), -1);
8552
- rb_define_method(cLogitMcState.klass, "brackt", VALUEFUNC(_wrap_LogitMcState_brackt_get), -1);
8553
- rb_define_method(cLogitMcState.klass, "stage1=", VALUEFUNC(_wrap_LogitMcState_stage1_set), -1);
8554
- rb_define_method(cLogitMcState.klass, "stage1", VALUEFUNC(_wrap_LogitMcState_stage1_get), -1);
8555
- rb_define_method(cLogitMcState.klass, "infoc=", VALUEFUNC(_wrap_LogitMcState_infoc_set), -1);
8556
- rb_define_method(cLogitMcState.klass, "infoc", VALUEFUNC(_wrap_LogitMcState_infoc_get), -1);
8557
- rb_define_method(cLogitMcState.klass, "dg=", VALUEFUNC(_wrap_LogitMcState_dg_set), -1);
8558
- rb_define_method(cLogitMcState.klass, "dg", VALUEFUNC(_wrap_LogitMcState_dg_get), -1);
8559
- rb_define_method(cLogitMcState.klass, "dgm=", VALUEFUNC(_wrap_LogitMcState_dgm_set), -1);
8560
- rb_define_method(cLogitMcState.klass, "dgm", VALUEFUNC(_wrap_LogitMcState_dgm_get), -1);
8561
- rb_define_method(cLogitMcState.klass, "dginit=", VALUEFUNC(_wrap_LogitMcState_dginit_set), -1);
8562
- rb_define_method(cLogitMcState.klass, "dginit", VALUEFUNC(_wrap_LogitMcState_dginit_get), -1);
8563
- rb_define_method(cLogitMcState.klass, "dgtest=", VALUEFUNC(_wrap_LogitMcState_dgtest_set), -1);
8564
- rb_define_method(cLogitMcState.klass, "dgtest", VALUEFUNC(_wrap_LogitMcState_dgtest_get), -1);
8565
- rb_define_method(cLogitMcState.klass, "dgx=", VALUEFUNC(_wrap_LogitMcState_dgx_set), -1);
8566
- rb_define_method(cLogitMcState.klass, "dgx", VALUEFUNC(_wrap_LogitMcState_dgx_get), -1);
8567
- rb_define_method(cLogitMcState.klass, "dgxm=", VALUEFUNC(_wrap_LogitMcState_dgxm_set), -1);
8568
- rb_define_method(cLogitMcState.klass, "dgxm", VALUEFUNC(_wrap_LogitMcState_dgxm_get), -1);
8569
- rb_define_method(cLogitMcState.klass, "dgy=", VALUEFUNC(_wrap_LogitMcState_dgy_set), -1);
8570
- rb_define_method(cLogitMcState.klass, "dgy", VALUEFUNC(_wrap_LogitMcState_dgy_get), -1);
8571
- rb_define_method(cLogitMcState.klass, "dgym=", VALUEFUNC(_wrap_LogitMcState_dgym_set), -1);
8572
- rb_define_method(cLogitMcState.klass, "dgym", VALUEFUNC(_wrap_LogitMcState_dgym_get), -1);
8573
- rb_define_method(cLogitMcState.klass, "finit=", VALUEFUNC(_wrap_LogitMcState_finit_set), -1);
8574
- rb_define_method(cLogitMcState.klass, "finit", VALUEFUNC(_wrap_LogitMcState_finit_get), -1);
8575
- rb_define_method(cLogitMcState.klass, "ftest1=", VALUEFUNC(_wrap_LogitMcState_ftest1_set), -1);
8576
- rb_define_method(cLogitMcState.klass, "ftest1", VALUEFUNC(_wrap_LogitMcState_ftest1_get), -1);
8577
- rb_define_method(cLogitMcState.klass, "fm=", VALUEFUNC(_wrap_LogitMcState_fm_set), -1);
8578
- rb_define_method(cLogitMcState.klass, "fm", VALUEFUNC(_wrap_LogitMcState_fm_get), -1);
8579
- rb_define_method(cLogitMcState.klass, "fx=", VALUEFUNC(_wrap_LogitMcState_fx_set), -1);
8580
- rb_define_method(cLogitMcState.klass, "fx", VALUEFUNC(_wrap_LogitMcState_fx_get), -1);
8581
- rb_define_method(cLogitMcState.klass, "fxm=", VALUEFUNC(_wrap_LogitMcState_fxm_set), -1);
8582
- rb_define_method(cLogitMcState.klass, "fxm", VALUEFUNC(_wrap_LogitMcState_fxm_get), -1);
8583
- rb_define_method(cLogitMcState.klass, "fy=", VALUEFUNC(_wrap_LogitMcState_fy_set), -1);
8584
- rb_define_method(cLogitMcState.klass, "fy", VALUEFUNC(_wrap_LogitMcState_fy_get), -1);
8585
- rb_define_method(cLogitMcState.klass, "fym=", VALUEFUNC(_wrap_LogitMcState_fym_set), -1);
8586
- rb_define_method(cLogitMcState.klass, "fym", VALUEFUNC(_wrap_LogitMcState_fym_get), -1);
8587
- rb_define_method(cLogitMcState.klass, "stx=", VALUEFUNC(_wrap_LogitMcState_stx_set), -1);
8588
- rb_define_method(cLogitMcState.klass, "stx", VALUEFUNC(_wrap_LogitMcState_stx_get), -1);
8589
- rb_define_method(cLogitMcState.klass, "sty=", VALUEFUNC(_wrap_LogitMcState_sty_set), -1);
8590
- rb_define_method(cLogitMcState.klass, "sty", VALUEFUNC(_wrap_LogitMcState_sty_get), -1);
8591
- rb_define_method(cLogitMcState.klass, "stmin=", VALUEFUNC(_wrap_LogitMcState_stmin_set), -1);
8592
- rb_define_method(cLogitMcState.klass, "stmin", VALUEFUNC(_wrap_LogitMcState_stmin_get), -1);
8593
- rb_define_method(cLogitMcState.klass, "stmax=", VALUEFUNC(_wrap_LogitMcState_stmax_set), -1);
8594
- rb_define_method(cLogitMcState.klass, "stmax", VALUEFUNC(_wrap_LogitMcState_stmax_get), -1);
8595
- rb_define_method(cLogitMcState.klass, "width=", VALUEFUNC(_wrap_LogitMcState_width_set), -1);
8596
- rb_define_method(cLogitMcState.klass, "width", VALUEFUNC(_wrap_LogitMcState_width_get), -1);
8597
- rb_define_method(cLogitMcState.klass, "width1=", VALUEFUNC(_wrap_LogitMcState_width1_set), -1);
8598
- rb_define_method(cLogitMcState.klass, "width1", VALUEFUNC(_wrap_LogitMcState_width1_get), -1);
8599
- rb_define_method(cLogitMcState.klass, "xtrapf=", VALUEFUNC(_wrap_LogitMcState_xtrapf_set), -1);
8600
- rb_define_method(cLogitMcState.klass, "xtrapf", VALUEFUNC(_wrap_LogitMcState_xtrapf_get), -1);
8601
- cLogitMcState.mark = 0;
8602
- cLogitMcState.destroy = (void (*)(void *)) free_logitmcstate;
8603
- cLogitMcState.trackObjects = 0;
8604
-
8605
- cMNLReport.klass = rb_define_class_under(mAlglib_ext, "MNLReport", rb_cObject);
8606
- SWIG_TypeClientData(SWIGTYPE_p_mnlreport, (void *) &cMNLReport);
8607
- rb_define_alloc_func(cMNLReport.klass, _wrap_MNLReport_allocate);
8608
- rb_define_method(cMNLReport.klass, "initialize", VALUEFUNC(_wrap_new_MNLReport), -1);
8609
- rb_define_method(cMNLReport.klass, "ngrad=", VALUEFUNC(_wrap_MNLReport_ngrad_set), -1);
8610
- rb_define_method(cMNLReport.klass, "ngrad", VALUEFUNC(_wrap_MNLReport_ngrad_get), -1);
8611
- rb_define_method(cMNLReport.klass, "nhess=", VALUEFUNC(_wrap_MNLReport_nhess_set), -1);
8612
- rb_define_method(cMNLReport.klass, "nhess", VALUEFUNC(_wrap_MNLReport_nhess_get), -1);
8613
- cMNLReport.mark = 0;
8614
- cMNLReport.destroy = (void (*)(void *)) free_mnlreport;
8615
- cMNLReport.trackObjects = 0;
8616
- rb_define_module_function(mAlglib_ext, "mnltrainh", VALUEFUNC(_wrap_mnltrainh), -1);
8617
- rb_define_module_function(mAlglib_ext, "mnlprocess", VALUEFUNC(_wrap_mnlprocess), -1);
8618
- rb_define_module_function(mAlglib_ext, "mnlunpack", VALUEFUNC(_wrap_mnlunpack), -1);
8619
- rb_define_module_function(mAlglib_ext, "mnlpack", VALUEFUNC(_wrap_mnlpack), -1);
8620
- rb_define_module_function(mAlglib_ext, "mnlserialize", VALUEFUNC(_wrap_mnlserialize), -1);
8621
- rb_define_module_function(mAlglib_ext, "mnlcopy", VALUEFUNC(_wrap_mnlcopy), -1);
8622
- rb_define_module_function(mAlglib_ext, "mnlunserialize", VALUEFUNC(_wrap_mnlunserialize), -1);
8623
- rb_define_module_function(mAlglib_ext, "mnlavgce", VALUEFUNC(_wrap_mnlavgce), -1);
8624
- rb_define_module_function(mAlglib_ext, "pcabuildbasis", VALUEFUNC(_wrap_pcabuildbasis), -1);
6124
+ rb_define_module_function(mAlglib_ext, "real1d_to_array", VALUEFUNC(_wrap_real1d_to_array), -1);
8625
6125
  }
8626
6126