alglib 1.0.0 → 1.0.1

data/ext/alglib/alglib_util.cpp

@@ -1,5 +1,5 @@
 #include "alglib_util.h"
-
+#include <iostream>
 
 VALUE real1d_to_array(ap::real_1d_array *x) {
     VALUE ar=rb_ary_new2(x->gethighbound()-x->getlowbound());
@@ -8,3 +8,12 @@ VALUE real1d_to_array(ap::real_1d_array *x) {
     }
     return ar;
 }
+
+void array_to_real1d(VALUE ary, ap::real_1d_array *x) {
+    x->setlength(RARRAY_LEN(ary));
+    //std::cout << "Largo:" << RARRAY_LEN(ary) << "\n";
+    for(long i=0;i<RARRAY_LEN(ary);i++) {
+      //  std::cout << "i:" << i << "=" <<  rb_num2dbl(RARRAY_PTR(ary)[i]) <<"\n";
+        x->operator()(i)=rb_num2dbl(RARRAY_PTR(ary)[i]);
+    }
+}

data/ext/alglib/alglib_util.h

@@ -4,9 +4,11 @@
 
 #include "ap.h"
 #include "linreg.h"
+#include "logit.h"
+
 #include "ruby.h"
 
 VALUE real1d_to_array(ap::real_1d_array *x);
-
+void array_to_real1d(VALUE ary, ap::real_1d_array *x);
 
 #endif

data/ext/ap.i

@@ -0,0 +1,97 @@
+%typemap(in) ap::real_1d_array {
+    $1 = new ap::real_1d_array();
+    $1->setlength(RARRAY_LEN($input));
+    for(long i=0;i<RARRAY_LEN($input);i++) {
+        $1->operator()(i)=rb_num2dbl(RARRAY_PTR($input)[i]);
+    }
+}
+
+
+%apply  ap::real_1d_array {ap::real_1d_array const &};
+
+namespace ap {
+/********************************************************************
+Template of a dynamical one-dimensional array
+********************************************************************/
+template<class T, bool Aligned = false>
+class template_1d_array
+{
+public:
+    template_1d_array(); 
+    ~template_1d_array();
+    template_1d_array(const template_1d_array &rhs);
+    %extend {
+        T __getitem__(int i) {
+            return $self->operator()(i);
+        };
+        T __setitem__(int i, T v) { 
+            return $self->operator()(i)=v;
+        };
+        int size() { 
+            return $self->gethighbound()-$self->getlowbound()+1;
+        }
+    }
+    
+    void setbounds( int iLow, int iHigh );
+    void setlength(int iLen);
+    void setcontent( int iLow, int iHigh, const T *pContent );
+    T* getcontent();
+    int getlowbound(int iBoundNum = 0);
+    int gethighbound(int iBoundNum = 0);
+};
+
+template<class T, bool Aligned = false>
+class template_2d_array
+{
+public:
+    template_2d_array();
+
+    ~template_2d_array();
+
+    template_2d_array(const template_2d_array &rhs);
+    T& operator()(int i1, int i2);
+    
+    void setbounds( int iLow1, int iHigh1, int iLow2, int iHigh2 );
+
+    void setlength(int iLen1, int iLen2);
+
+    void setcontent( int iLow1, int iHigh1, int iLow2, int iHigh2, const T *pContent );
+
+    int getlowbound(int iBoundNum) const;
+
+    int gethighbound(int iBoundNum) const;
+    
+    %extend {
+    double __getitem__(int x,int y) {
+        return $self->operator()(x,y);
+    }
+    void __setitem__(int x,int y, T val) {
+        $self->operator()(x,y)=val;
+    }
+
+}
+    
+};
+
+
+
+typedef template_1d_array<int>          integer_1d_array;
+typedef template_1d_array<double,true>  real_1d_array;
+typedef template_1d_array<complex>      complex_1d_array;
+typedef template_1d_array<bool>         boolean_1d_array;
+
+typedef template_2d_array<int>          integer_2d_array;
+typedef template_2d_array<double,true>  real_2d_array;
+typedef template_2d_array<complex>      complex_2d_array;
+typedef template_2d_array<bool>         boolean_2d_array;
+
+%template(Integer1dArray) template_1d_array<int>;
+%template(Real1dArray) template_1d_array<double,true>;
+%template(Boolean1dArray) template_1d_array<bool>;
+%template(Integer2dArray) template_2d_array<int>;
+%template(Real2dArray) template_2d_array<double,true>;
+};
+
+
+VALUE real1d_to_array(ap::real_1d_array *x);
+void array_to_real1d(VALUE ary, ap::real_1d_array *x);

data/ext/correlation.i

@@ -0,0 +1,24 @@
+%{
+#include "correlation.h"
+#include "ialglib.h"
+%}
+
+// Complete wrapping and testing
+
+double pearsoncorrelation(const ap::real_1d_array& x,
+     const ap::real_1d_array& y,
+     int n);
+     
+%rename(spearmanrankcorrelation) wrap_spearmanrankcorrelation;
+%inline %{
+double wrap_spearmanrankcorrelation(const ap::real_1d_array& x,
+     const ap::real_1d_array& y,
+     int n) {
+     ap::real_1d_array x1,y1;
+     x1=x;
+     y1=y;
+     return spearmanrankcorrelation(x1,y1,n);
+     
+}
+%}
+

data/ext/extconf.rb

@@ -1,4 +1,5 @@
 require 'mkmf'
+$CFLAGS+=" -DEBUG "
 $libs = append_library($libs, "supc++")
 $libs = append_library($libs, "stdc++")
 create_makefile("alglib_ext","alglib")

data/ext/logit.i

@@ -0,0 +1,89 @@
+%{
+#include "logit.h"
+%}
+/**
+* Logit
+*/
+
+%rename (LogitModel) logitmodel;
+%rename (LogitMcState) logitmcstate;
+%rename (MNLReport) mnlreport;
+struct logitmodel
+{
+    ap::real_1d_array w;
+};
+struct logitmcstate
+{
+    bool brackt;
+    bool stage1;
+    int infoc;
+    double dg;
+    double dgm;
+    double dginit;
+    double dgtest;
+    double dgx;
+    double dgxm;
+    double dgy;
+    double dgym;
+    double finit;
+    double ftest1;
+    double fm;
+    double fx;
+    double fxm;
+    double fy;
+    double fym;
+    double stx;
+    double sty;
+    double stmin;
+    double stmax;
+    double width;
+    double width1;
+    double xtrapf;
+};
+struct mnlreport
+{
+    int ngrad;
+    int nhess;
+};
+
+
+void mnltrainh(const ap::real_2d_array& xy,
+     int npoints,
+     int nvars,
+     int nclasses,
+     int& info,
+     logitmodel& lm,
+     mnlreport& rep);
+
+     
+%rename(mnlprocess) wrap_mnlprocess;
+%inline %{
+VALUE wrap_mnlprocess(logitmodel& lm,
+     const ap::real_1d_array& x) {
+     ap::real_1d_array y;
+//     y.setlength(lm.w(3));
+     mnlprocess(lm,x,y);
+     // std::cout << "Saliendo";
+     return real1d_to_array(&y);
+}
+%}
+     
+     
+     
+void mnlunpack(const logitmodel& lm,
+     ap::real_2d_array& a,
+     int& nvars,
+     int& nclasses);
+     
+void mnlpack(const ap::real_2d_array& a,
+     int nvars,
+     int nclasses,
+     logitmodel& lm);
+
+     
+void mnlserialize(const logitmodel& lm, ap::real_1d_array& ra, int& rlen);
+     
+void mnlcopy(const logitmodel& lm1, logitmodel& lm2);
+
+void mnlunserialize(const ap::real_1d_array& ra, logitmodel& lm);
+double mnlavgce(logitmodel& lm, const ap::real_2d_array& xy, int npoints);

data/lib/alglib.rb

@@ -1,3 +1,5 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__)+"/../ext"))
+$:.unshift(File.expand_path(File.dirname(__FILE__)+"/../lib"))
 require 'alglib_ext'
 require 'matrix'
 class Matrix
@@ -12,67 +14,32 @@ class Matrix
         a_matrix
     end
 end
-module Alglib
-    VERSION = '1.0.0'
-    class LinearRegression
-        attr_reader :model, :cases, :ivars
-        # Creates a Linear Regression object based on a Matrix
-        # EXAMPLE: 
-        #   require 'alglib'
-        #   matrix=Matrix[[2,3,4],[2,5,5],[1,5,3],[4,6,5]]
-        #   lr=Alglib::LinearRegression.build_from_matrix(matrix)
-        #     => #<Alglib::LinearRegression:0x7ffaf6c05dc0 @model=#<Alglib_ext::LinearModel:0x7ffaf6c05e60>, @cases=4, @report=#<Alglib_ext::LrReport:0x7ffaf6c05e10>, @ivars=2>
-        #     lr.coeffs
-        #     => [0.585714285714286, -0.0142857142857142]
+require 'alglib/linearregression.rb'
+require 'alglib/logit.rb'
+require 'alglib/correlation.rb'
 
-        def self.build_from_matrix(matrix)
-            raise "Argument should be a matrix" unless matrix.is_a? Matrix
-            cases=matrix.row_size
-            ivars=matrix.column_size-1
-            lm=Alglib_ext::LinearModel.new
-            lr=Alglib_ext::LrReport.new
-            am=matrix.to_alglib_matrix
-            Alglib_ext::lrbuild(am,cases,ivars,lm,lr)
-            self.new(lm,lr,cases,ivars)
-        end
-        # Use with care...
-        def initialize(lm,lr,cases,ivars)
-            @model=lm
-            @report=lr
-            @cases=cases
-            @ivars=ivars
-        end
-        # Constant value. a on
-        # y= a+b1x1+b2x2...
-        
-        def constant
-            v=Alglib_ext::Real1dArray.new
-            Alglib_ext::lrunpack(@model,v, @ivars);
-            Alglib_ext.real1d_to_array(v).slice(-1)
-        end
-        # Array with b coeffs.  
-        def coeffs
-            v=Alglib_ext::Real1dArray.new
-            Alglib_ext::lrunpack(@model,v, @ivars);
-            Alglib_ext.real1d_to_array(v)[0,v.size]
-        end
-        # Predict an y value based on an array of predictors.
-        def process(vector)
-            Alglib_ext::lrprocess(@model,vector);
-        end
-        # A wrapper for lm_report
-        def report
-            {:c=>@report.c,
-                :rmserror=>@report.rmserror,
-                :avgerror=>@report.avgerror,
-                :avgrelerror=>@report.avgrelerror,
-                :cvrmserror=>@report.cvrmserror,
-                :cvavgerror=>@report.cvavgerror,
-                :cvavgrelerror=>@report.cvavgrelerror,
-                :ncvdefects=>@report.ncvdefects,
-                :cvdefects=>@report.cvdefects
+module Alglib
+    VERSION = '1.0.1'
+    
+    def self.array_to_real1darray(a)
+        v=Alglib_ext::Real1dArray.new
+        Alglib_ext.array_to_real1d(a,v)
+        v
+    end
+    
+    def self.real2darray_to_array(a)
+        lr=a.getlowbound(1)
+        lc=a.getlowbound(2)
+        hr=a.gethighbound(1)
+        hc=a.gethighbound(2)
+        out=[]
+        (lr..hr).each{|x|
+            row=[]
+            (lc..hc).each{|y|
+                row[y]=a[x,y]
             }
-        end
-        
+            out[x]=row
+        }
+        out
     end
 end

data/lib/alglib/correlation.rb

@@ -0,0 +1,26 @@
+module Alglib
+    # Retrieves Pearson correlation for two arrays
+    def self.pearson_correlation(a,b)
+        raise ArgumentError "argument should be the same size" if a.size!=b.size
+        Alglib_ext::pearsoncorrelation(a,b,a.size)
+    end
+    # Retrieves Spearman ranked correlation for two arrays
+    # Equal to Pearson correlation for ranked data
+
+    def self.spearman_correlation(a,b)
+        raise ArgumentError "argument should be the same size" if a.size!=b.size
+        Alglib_ext::spearmanrankcorrelation(a,b,a.size)
+    end
+    # Retrieves significance for pearson correlation for one or two tails
+    # Returns a hash with keys :both, :left and :right
+    def self.pearson_correlation_significance(r,size)
+        out={}
+        out[:both], out[:left], out[:right] = Alglib_ext::pearsoncorrelationsignificance(r, size)
+        out
+    end
+    def self.spearman_correlation_significance(r,size)
+        out={}
+        out[:both], out[:left], out[:right] = Alglib_ext::spearmanrankcorrelationsignificance(r, size)
+        out
+    end
+end

data/lib/alglib/linearregression.rb

@@ -0,0 +1,63 @@
+module Alglib
+    class LinearRegression
+        attr_reader :model, :cases, :ivars
+        # Creates a Linear Regression object based on a Matrix
+        # EXAMPLE: 
+        #   require 'alglib'
+        #   matrix=Matrix[[2,3,4],[2,5,5],[1,5,3],[4,6,5]]
+        #   lr=Alglib::LinearRegression.build_from_matrix(matrix)
+        #     => #<Alglib::LinearRegression:0x7ffaf6c05dc0 @model=#<Alglib_ext::LinearModel:0x7ffaf6c05e60>, @cases=4, @report=#<Alglib_ext::LrReport:0x7ffaf6c05e10>, @ivars=2>
+        #     lr.coeffs
+        #     => [0.585714285714286, -0.0142857142857142]
+
+        def self.build_from_matrix(matrix)
+            raise "Argument should be a matrix" unless matrix.is_a? Matrix
+            cases=matrix.row_size
+            ivars=matrix.column_size-1
+            lm=Alglib_ext::LinearModel.new
+            lr=Alglib_ext::LrReport.new
+            am=matrix.to_alglib_matrix
+            Alglib_ext::lrbuild(am,cases,ivars,lm,lr)
+            self.new(lm,lr,cases,ivars)
+        end
+        # Use with care...
+        def initialize(lm,lr,cases,ivars)
+            @model=lm
+            @report=lr
+            @cases=cases
+            @ivars=ivars
+        end
+        # Constant value. a on
+        # y= a+b1x1+b2x2...
+        
+        def constant
+            v=Alglib_ext::Real1dArray.new
+            Alglib_ext::lrunpack(@model,v, @ivars);
+            Alglib_ext.real1d_to_array(v).slice(-1)
+        end
+        # Array with b coeffs.  
+        def coeffs
+            v=Alglib_ext::Real1dArray.new
+            Alglib_ext::lrunpack(@model,v, @ivars);
+            Alglib_ext.real1d_to_array(v)[0,v.size]
+        end
+        # Predict an y value based on an array of predictors.
+        def process(vector)
+            Alglib_ext::lrprocess(@model,vector);
+        end
+        # A wrapper for lm_report
+        def report
+            {:c=>@report.c,
+                :rmserror=>@report.rmserror,
+                :avgerror=>@report.avgerror,
+                :avgrelerror=>@report.avgrelerror,
+                :cvrmserror=>@report.cvrmserror,
+                :cvavgerror=>@report.cvavgerror,
+                :cvavgrelerror=>@report.cvavgrelerror,
+                :ncvdefects=>@report.ncvdefects,
+                :cvdefects=>@report.cvdefects
+            }
+        end
+        
+    end
+end

data/lib/alglib/logit.rb

@@ -0,0 +1,42 @@
+module Alglib
+    class Logit
+        attr_reader :model, :cases, :ivars
+        # Creates a Logit object based on a Matrix
+        # EXAMPLE: 
+        #   require 'alglib'
+        #   matrix=Matrix[[2,3,4],[2,5,5],[1,5,3],[4,6,5]]
+        #   lr=Alglib::LinearRegression.build_from_matrix(matrix)
+        #     => #<Alglib::LinearRegression:0x7ffaf6c05dc0 @model=#<Alglib_ext::LinearModel:0x7ffaf6c05e60>, @cases=4, @report=#<Alglib_ext::LrReport:0x7ffaf6c05e10>, @ivars=2>
+        #     lr.coeffs
+        #     => [0.585714285714286, -0.0142857142857142]
+
+        def self.build_from_matrix(matrix)
+            raise "Argument should be a matrix" unless matrix.is_a? Matrix
+            cases=matrix.row_size
+            ivars=matrix.column_size-1
+            lm=Alglib_ext::LogitModel.new
+            lr=Alglib_ext::MNLReport.new
+            nclasses=matrix.column(matrix.column_size-1).to_a.uniq.size
+            am=matrix.to_alglib_matrix
+            Alglib_ext::mnltrainh(am,cases,ivars,nclasses,lm,lr)
+            self.new(lm,lr,cases,ivars,nclasses)
+        end
+        # Use with care...
+        def initialize(lm,lr,cases,ivars,nclasses)
+            @model=lm
+            @report=lr
+            @cases=cases
+            @ivars=ivars
+            @nclasses=nclasses
+        end
+        def process(vector)
+            Alglib_ext.mnlprocess(@model,vector)
+        end
+        def unpack
+            a2d=Alglib_ext::Real2dArray.new
+            Alglib_ext::mnlunpack(@model, a2d,@ivars,@nclasses);
+            Alglib.real2darray_to_array(a2d)
+        end
+
+    end
+end