regression 0.0.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 German Antsiferov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,32 @@
+require 'lib/regression/version'
+require 'rake/extensiontask'
+
+spec = Gem::Specification.new 'regression', Regression::VERSION do |s|
+  s.authors = ["German Antsiferov"]
+  s.email   = ["dxdy@bk.ru"]
+  s.summary = %q{This project implements a simple least-squares polynomial fit}
+  s.license = "MIT"
+
+  s.extensions = %w[ext/regression/extconf.rb]
+
+  s.files = %w[
+    LICENSE.txt
+    Rakefile
+    lib/regression.rb
+    lib/regression/version.rb
+    ext/regression/extconf.rb
+    ext/regression/regression.c
+  ]
+
+  s.add_development_dependency "rake-compiler", "~> 0.8"
+  s.add_development_dependency "rspec", "~> 3.3"
+end
+
+Gem::PackageTask.new(spec) do |pkg|
+end
+
+Rake::ExtensionTask.new('regression', spec) do |ext|
+  ext.lib_dir = "lib/regression"
+end
+
+task :default => [:compile]

data/ext/regression/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile("regression/regression")

data/ext/regression/regression.c

@@ -0,0 +1,211 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+#include <ruby.h>
+
+//----------------------------------------------------
+//
+// METHOD:  polyfit
+//
+// INPUTS:  dependentValues[0..(countOfElements-1)]
+//          independentValues[0...(countOfElements-1)]
+//          countOfElements
+//          order - Order of the polynomial fitting
+//
+// OUTPUTS: coefficients[0..order] - indexed by term
+//               (the (coef*x^3) is coefficients[3])
+//
+// HOMEPAGE: https://github.com/natedomin/polyfit.git
+//
+//----------------------------------------------------
+int polyfit(const double* const dependentValues,
+            const double* const independentValues,
+            unsigned int        countOfElements,
+            unsigned int        order,
+            double*             coefficients)
+{
+    // Declarations...
+    // ----------------------------------
+    const unsigned int maxNoOfElements = 50; // Arbitrary
+    enum {maxOrder = 5};
+
+    double B[maxOrder+1] = {0.0f};
+    double P[((maxOrder+1) * 2)+1] = {0.0f};
+    double A[(maxOrder + 1)*2*(maxOrder + 1)] = {0.0f};
+
+    double x, y, powx;
+
+    unsigned int ii, jj, kk;
+
+    // Verify initial conditions....
+    // ----------------------------------
+
+    // This method requires that the countOfElements >
+    // (order+1)
+    if (countOfElements <= order)
+        return -1;
+
+    // This method has imposed an arbitrary bound of
+    // order <= maxOrder.  Increase maxOrder if necessary.
+    if (order > maxOrder)
+        return -1;
+
+    // This method has imposed an arbitrary bound of
+    // countOfElements <= maxNoOfElements
+    if (countOfElements > maxNoOfElements)
+        return -1;
+
+    // Begin Code...
+    // ----------------------------------
+
+    // Identify the column vector
+    for (ii = 0; ii < countOfElements; ii++)
+    {
+        x    = dependentValues[ii];
+        y    = independentValues[ii];
+        powx = 1;
+
+        for (jj = 0; jj < (order + 1); jj++)
+        {
+            B[jj] = B[jj] + (y * powx);
+            powx  = powx * x;
+        }
+    }
+
+    // Initialize the PowX array
+    P[0] = countOfElements;
+
+    // Compute the sum of the Powers of X
+    for (ii = 0; ii < countOfElements; ii++)
+    {
+        x    = dependentValues[ii];
+        powx = dependentValues[ii];
+
+        for (jj = 1; jj < ((2 * (order + 1)) + 1); jj++)
+        {
+            P[jj] = P[jj] + powx;
+            powx  = powx * x;
+        }
+    }
+
+    // Initialize the reduction matrix
+    //
+    for (ii = 0; ii < (order + 1); ii++)
+    {
+        for (jj = 0; jj < (order + 1); jj++)
+        {
+            A[(ii * (2 * (order + 1))) + jj] = P[ii+jj];
+        }
+
+        A[(ii*(2 * (order + 1))) + (ii + (order + 1))] = 1;
+    }
+
+    // Move the Identity matrix portion of the redux matrix
+    // to the left side (find the inverse of the left side
+    // of the redux matrix
+    for (ii = 0; ii < (order + 1); ii++)
+    {
+        x = A[(ii * (2 * (order + 1))) + ii];
+        if (x != 0)
+        {
+            for (kk = 0; kk < (2 * (order + 1)); kk++)
+            {
+                A[(ii * (2 * (order + 1))) + kk] =
+                    A[(ii * (2 * (order + 1))) + kk] / x;
+            }
+
+            for (jj = 0; jj < (order + 1); jj++)
+            {
+                if ((jj - ii) != 0)
+                {
+                    y = A[(jj * (2 * (order + 1))) + ii];
+                    for (kk = 0; kk < (2 * (order + 1)); kk++)
+                    {
+                        A[(jj * (2 * (order + 1))) + kk] =
+                            A[(jj * (2 * (order + 1))) + kk] -
+                            y * A[(ii * (2 * (order + 1))) + kk];
+                    }
+                }
+            }
+        }
+        else
+        {
+            // Cannot work with singular matrices
+            return -1;
+        }
+    }
+
+    // Calculate and Identify the coefficients
+    for (ii = 0; ii < (order + 1); ii++)
+    {
+        for (jj = 0; jj < (order + 1); jj++)
+        {
+            x = 0;
+            for (kk = 0; kk < (order + 1); kk++)
+            {
+                x = x + (A[(ii * (2 * (order + 1))) + (kk + (order + 1))] *
+                    B[kk]);
+            }
+            coefficients[ii] = x;
+        }
+    }
+
+    return 0;
+}
+
+static VALUE
+rb_polyfit(VALUE rb_self, VALUE rb_x_array, VALUE rb_y_array, VALUE rb_order)
+{
+  VALUE rb_c_array;
+
+  char status;
+  unsigned int i, order, length, order_length;
+  double *x_array, *y_array, *c_array;
+
+  Check_Type(rb_x_array, T_ARRAY);
+  Check_Type(rb_y_array, T_ARRAY);
+
+  order = NUM2INT(rb_order);
+  order_length = order + 1;
+  length = (unsigned int)RARRAY_LEN(rb_x_array);
+
+  rb_c_array = rb_ary_new2(order_length);
+
+  if (!length)
+    return rb_c_array;
+
+  c_array = malloc(order_length * sizeof(double));
+  x_array = malloc(length * sizeof(double));
+  y_array = malloc(length * sizeof(double));
+
+  for(i = 0; i < length; ++i)
+  {
+    x_array[i] = NUM2DBL( rb_ary_entry(rb_x_array, i) );
+    y_array[i] = NUM2DBL( rb_ary_entry(rb_y_array, i) );
+  }
+
+  status = polyfit(x_array, y_array, length, order, c_array);
+
+  free(x_array);
+  free(y_array);
+
+  if (!status)
+  {
+    for(i = 0; i < order_length; ++i)
+    {
+      rb_ary_store(rb_c_array, i, rb_float_new(c_array[i]));
+    }
+  }
+
+  return rb_c_array;
+}
+
+void Init_regression(void)
+{
+  VALUE rb_mRegression;
+
+  rb_mRegression = rb_const_get(rb_cObject, rb_intern("Regression"));
+  rb_define_module_function(rb_mRegression, "polyfit", rb_polyfit, 3);
+}

data/lib/regression.rb

@@ -0,0 +1,6 @@
+require 'regression/version'
+
+module Regression
+end
+
+require "regression/regression"

data/lib/regression/version.rb

@@ -0,0 +1,3 @@
+module Regression
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: regression
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- German Antsiferov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2015-10-22 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake-compiler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 8
+        version: "0.8"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 3
+        - 3
+        version: "3.3"
+  type: :development
+  version_requirements: *id002
+description: 
+email: 
+- dxdy@bk.ru
+executables: []
+
+extensions: 
+- ext/regression/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- LICENSE.txt
+- Rakefile
+- lib/regression.rb
+- lib/regression/version.rb
+- ext/regression/extconf.rb
+- ext/regression/regression.c
+has_rdoc: true
+homepage: 
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: This project implements a simple least-squares polynomial fit
+test_files: []
+