lowess 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3f8e62062c82338a4acfc42b4bab9bc873ab8535
+  data.tar.gz: 0b7607b81e80f5574d82f94373438496c8f84829
+SHA512:
+  metadata.gz: 65736717ab720df61c4bd05f3d51c6beaa96710dc340c65f2170b22d7ee36f0345b7647eda3f01b9904cc7c76d8d844a126a588b21aa2b01e7a665f279882c50
+  data.tar.gz: 7e12d26d8d291c78cff4d80349c72294ac16c51b93adc3e19bc6049aebc5e9175461851886ce2b8bfbaf01bbead4beb1bc2dc01d7340487e901e53fe66e68b67

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+*.o
+*.so
+*.swp
+tmp/
+Makefile

data/.ruby-gemset

@@ -0,0 +1 @@
+pollster

data/.ruby-version

@@ -0,0 +1 @@
+2.2.3

data/README.md

@@ -0,0 +1,37 @@
+If you've ever used R's [lowess()](https://svn.r-project.org/R/tags/R-3-2-4/src/library/stats/src/lowess.doc)
+and you wish you could call it from Ruby, this gem's for you.
+
+# Installation
+
+`gem install lowess`
+
+or in your Gemfile:
+
+`gem 'lowess'`
+
+# Usage
+
+```rb
+require 'lowess'
+
+points = [
+  Lowess::Point.new(1, 1.1),
+  Lowess::Point.new(1.3, 1.3),
+  Lowess::Point.new(1.7, 1.1),
+  Lowess::Point.new(2.1, 1.1)
+]
+
+# returns (1, 1.1531) (1.3, 1.1854) (1.7, 1.3444) (2.1, 1.6363)
+Lowess::lowess(points, f: 1.0, iter: 4)
+```
+
+# Development
+
+*To run tests*: `rake`
+
+*To fiddle with C*: look in `ext/ext_lowess`
+
+# License
+
+[GPL2](http://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html) because the
+code is downloaded from R automatically.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake/extensiontask'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+gemspec = Gem::Specification.load('lowess.gemspec')
+Rake::ExtensionTask.new('ext_lowess')
+
+task default: [ :compile, :test ]

data/ext/ext_lowess/README.md

@@ -0,0 +1 @@
+clowess.c is copied from R, which makes this whole project GPL

data/ext/ext_lowess/clowess.c

@@ -0,0 +1,308 @@
+/*
+ *  R : A Computer Langage for Statistical Data Analysis
+ *  Copyright (C) 1996  Robert Gentleman and Ross Ihaka
+ *  Copyright (C) 1999-20012 The R Core Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, a copy is available at
+ *  https://www.R-project.org/Licenses/
+ */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#ifdef ENABLE_NLS
+#include <libintl.h>
+#define _(String) dgettext ("stats", String)
+#else
+#define _(String) (String)
+#endif
+
+#include <math.h>
+double fmax2(double x, double y) { return (x < y) ? y : x; }
+int imin2(int x, int y) { return (x < y) ? x : y; }
+int imax2(int x, int y) { return (x < y) ? y : x; }
+		/* fmax2, imin2, imax2 */
+#define R_INLINE inline	/* prototypes for lowess and clowess */
+typedef enum { FALSE = 0, TRUE /*, MAYBE */ } Rboolean;
+
+static void rPsort2(double *x, int lo, int hi, int k)
+{
+  double v, w;
+  int L, R, i, j;
+
+  for (L = lo, R = hi; L < R; ) {
+    v = x[k];
+    for(i = L, j = R; i <= j;) {
+      while (x[i] < v) i++;
+      while (v < x[j]) j--;
+      if (i <= j) { w = x[i]; x[i++] = x[j]; x[j--] = w; }
+    }
+    if (j < k) L = i;
+    if (k < i) R = j;
+  }
+}
+
+static void rPsort(double *x, int n, int k)
+{
+  rPsort2(x, 0, n-1, k);
+}
+	/* rPsort() */
+#ifdef DEBUG_lowess
+# include <R_ext/Print.h>
+#endif
+
+static R_INLINE double fsquare(double x)
+{
+    return x * x;
+}
+
+static R_INLINE double fcube(double x)
+{
+    return x * x * x;
+}
+
+static void lowest(double *x, double *y, int n, double *xs, double *ys,
+	int nleft, int nright, double *w,
+	Rboolean userw, double *rw, Rboolean *ok)
+{
+    int nrt, j;
+    double a, b, c, h, h1, h9, r, range;
+
+    x--;
+    y--;
+    w--;
+    rw--;
+
+    range = x[n]-x[1];
+    h = fmax2(*xs-x[nleft], x[nright]-*xs);
+    h9 = 0.999*h;
+    h1 = 0.001*h;
+
+    /* sum of weights */
+
+    a = 0.;
+    j = nleft;
+    while (j <= n) {
+
+	/* compute weights */
+	/* (pick up all ties on right) */
+
+	w[j] = 0.;
+	r = fabs(x[j] - *xs);
+	if (r <= h9) {
+	    if (r <= h1)
+		w[j] = 1.;
+	    else
+		w[j] = fcube(1.-fcube(r/h));
+	    if (userw)
+		w[j] *= rw[j];
+	    a += w[j];
+	}
+	else if (x[j] > *xs)
+	    break;
+	j = j+1;
+    }
+
+    /* rightmost pt (may be greater */
+    /* than nright because of ties) */
+
+    nrt = j-1;
+    if (a <= 0.)
+	*ok = FALSE;
+    else {
+	*ok = TRUE;
+
+	/* weighted least squares */
+	/* make sum of w[j] == 1 */
+
+	for(j=nleft ; j<=nrt ; j++)
+	    w[j] /= a;
+	if (h > 0.) {
+	    a = 0.;
+
+	    /*  use linear fit */
+	    /* weighted center of x values */
+
+	    for(j=nleft ; j<=nrt ; j++)
+		a += w[j] * x[j];
+	    b = *xs - a;
+	    c = 0.;
+	    for(j=nleft ; j<=nrt ; j++)
+		c += w[j]*fsquare(x[j]-a);
+	    if (sqrt(c) > 0.001*range) {
+		b /= c;
+
+		/* points are spread out */
+		/* enough to compute slope */
+
+		for(j=nleft; j <= nrt; j++)
+		    w[j] *= (b*(x[j]-a) + 1.);
+	    }
+	}
+	*ys = 0.;
+	for(j=nleft; j <= nrt; j++)
+	    *ys += w[j] * y[j];
+    }
+}
+
+void clowess(double *x, double *y, int n,
+	     double f, int nsteps, double delta,
+	     double *ys, double *rw, double *res)
+{
+    int i, iter, j, last, m1, m2, nleft, nright, ns;
+    Rboolean ok;
+    double alpha, c1, c9, cmad, cut, d1, d2, denom, r, sc;
+
+    if (n < 2) {
+	ys[0] = y[0]; return;
+    }
+
+    /* nleft, nright, last, etc. must all be shifted to get rid of these: */
+    x--;
+    y--;
+    ys--;
+
+
+    /* at least two, at most n points */
+    ns = imax2(2, imin2(n, (int)(f*n + 1e-7)));
+#ifdef DEBUG_lowess
+    REprintf("lowess(): ns = %d\n", ns);
+#endif
+
+    /* robustness iterations */
+
+    iter = 1;
+    while (iter <= nsteps+1) {
+	nleft = 1;
+	nright = ns;
+	last = 0;	/* index of prev estimated point */
+	i = 1;		/* index of current point */
+
+	for(;;) {
+	    if (nright < n) {
+
+		/* move nleft,  nright to right */
+		/* if radius decreases */
+
+		d1 = x[i] - x[nleft];
+		d2 = x[nright+1] - x[i];
+
+		/* if d1 <= d2 with */
+		/* x[nright+1] == x[nright], */
+		/* lowest fixes */
+
+		if (d1 > d2) {
+
+		    /* radius will not */
+		    /* decrease by */
+		    /* move right */
+
+		    nleft++;
+		    nright++;
+		    continue;
+		}
+	    }
+
+	    /* fitted value at x[i] */
+
+	    lowest(&x[1], &y[1], n, &x[i], &ys[i],
+		   nleft, nright, res, iter>1, rw, &ok);
+	    if (!ok) ys[i] = y[i];
+
+	    /* all weights zero */
+	    /* copy over value (all rw==0) */
+
+	    if (last < i-1) {
+		denom = x[i]-x[last];
+
+		/* skipped points -- interpolate */
+		/* non-zero - proof? */
+
+		for(j = last+1; j < i; j++) {
+		    alpha = (x[j]-x[last])/denom;
+		    ys[j] = alpha*ys[i] + (1.-alpha)*ys[last];
+		}
+	    }
+
+	    /* last point actually estimated */
+	    last = i;
+
+	    /* x coord of close points */
+	    cut = x[last]+delta;
+	    for (i = last+1; i <= n; i++) {
+		if (x[i] > cut)
+		    break;
+		if (x[i] == x[last]) {
+		    ys[i] = ys[last];
+		    last = i;
+		}
+	    }
+	    i = imax2(last+1, i-1);
+	    if (last >= n)
+		break;
+	}
+	/* residuals */
+	for(i = 0; i < n; i++)
+	    res[i] = y[i+1] - ys[i+1];
+
+	/* overall scale estimate */
+	sc = 0.;
+	for(i = 0; i < n; i++) sc += fabs(res[i]);
+	sc /= n;
+
+	/* compute robustness weights */
+	/* except last time */
+
+	if (iter > nsteps)
+	    break;
+	/* Note: The following code, biweight_{6 MAD|Ri|}
+	   is also used in stl(), loess and several other places.
+	   --> should provide API here (MM) */
+	for(i = 0 ; i < n ; i++)
+	    rw[i] = fabs(res[i]);
+
+	/* Compute   cmad := 6 * median(rw[], n)  ---- */
+	/* FIXME: We need C API in R for Median ! */
+	m1 = n/2;
+	/* partial sort, for m1 & m2 */
+	rPsort(rw, n, m1);
+	if(n % 2 == 0) {
+	    m2 = n-m1-1;
+	    rPsort(rw, n, m2);
+	    cmad = 3.*(rw[m1]+rw[m2]);
+	}
+	else { /* n odd */
+	    cmad = 6.*rw[m1];
+	}
+#ifdef DEBUG_lowess
+	REprintf("   cmad = %12g\n", cmad);
+#endif
+	if(cmad < 1e-7 * sc) /* effectively zero */
+	    break;
+	c9 = 0.999*cmad;
+	c1 = 0.001*cmad;
+	for(i = 0 ; i < n ; i++) {
+	    r = fabs(res[i]);
+	    if (r <= c1)
+		rw[i] = 1.;
+	    else if (r <= c9)
+		rw[i] = fsquare(1.-fsquare(r/cmad));
+	    else
+		rw[i] = 0.;
+	}
+	iter++;
+    }
+}
+

data/ext/ext_lowess/download_clowess.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require 'open-uri'
+
+clowess = open('https://svn.r-project.org/R/tags/R-3-2-4/src/library/stats/src/lowess.c') { |f| f.read }
+
+rmath_stub = <<EOT
+double fmax2(double x, double y) { return (x < y) ? y : x; }
+int imin2(int x, int y) { return (x < y) ? x : y; }
+int imax2(int x, int y) { return (x < y) ? y : x; }
+EOT
+
+boolean_stub = <<EOT
+typedef enum { FALSE = 0, TRUE /*, MAYBE */ } Rboolean;
+EOT
+
+# From https://svn.r-project.org/R/tags/R-3-2-4/src/main/sort.c
+rpsort_stub = <<EOT
+static void rPsort2(double *x, int lo, int hi, int k)
+{
+  double v, w;
+  int L, R, i, j;
+
+  for (L = lo, R = hi; L < R; ) {
+    v = x[k];
+    for(i = L, j = R; i <= j;) {
+      while (x[i] < v) i++;
+      while (v < x[j]) j--;
+      if (i <= j) { w = x[i]; x[i++] = x[j]; x[j--] = w; }
+    }
+    if (j < k) L = i;
+    if (k < i) R = j;
+  }
+}
+
+static void rPsort(double *x, int n, int k)
+{
+  rPsort2(x, 0, n-1, k);
+}
+EOT
+
+out = clowess
+  .sub(/#include <Rmath\.h>/, rmath_stub)
+  .sub(/#include <R_ext\/Applic\.h>/, '#define R_INLINE inline')
+  .sub(/#include <R_ext\/Boolean\.h>/, boolean_stub)
+  .sub(/#include <R_ext\/Utils\.h>/, rpsort_stub)
+  .sub(/static\r?\nvoid clowess/, 'void clowess')
+  .sub(/#include <Rinternals.*/m, '') # drop the R wrapper
+
+open('clowess.c', 'w') { |f| f.write(out) }

data/ext/ext_lowess/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+dir_config('ext_lowess')
+create_makefile('ext_lowess')

data/ext/ext_lowess/lowess.c

@@ -0,0 +1,69 @@
+#include <ruby.h>
+
+static VALUE Lowess;
+static VALUE Lowess_Point;
+
+static ID X;
+static ID Y;
+static ID Point;
+
+void clowess(double *x, double *y, int n,
+             double f, int nsteps, double delta,
+             double *ys, double *rw, double *res);
+
+static VALUE
+lowess_ext_lowess(VALUE self, VALUE in_points, VALUE in_f, VALUE in_iter, VALUE in_delta) {
+  const int len = RARRAY_LEN(in_points);
+
+  double* xs = ALLOC_N(double, len);
+  double* ys = ALLOC_N(double, len);
+
+  const double f = NUM2DBL(in_f);
+  const int iter = NUM2INT(in_iter);
+  const double delta = NUM2DBL(in_delta);
+
+  double* out_ys = ALLOC_N(double, len);
+  double* rw = ALLOC_N(double, len);
+  double* res = ALLOC_N(double, len);
+  VALUE* points = ALLOC_N(VALUE, len);
+  VALUE point_args[2];
+  VALUE ret = rb_ary_new_capa(len);
+  int i;
+
+  VALUE e;
+  for (i = 0; i < len; i++) {
+    e = rb_ary_entry(in_points, i);
+    xs[i] = NUM2DBL(rb_ivar_get(e, X));
+    ys[i] = NUM2DBL(rb_ivar_get(e, Y));
+  }
+
+  clowess(xs, ys, len, f, iter, delta, out_ys, rw, res);
+
+  for (i = 0; i < len; i++) {
+    point_args[0] = DBL2NUM(xs[i]);
+    point_args[1] = DBL2NUM(out_ys[i]);
+    points[i] = rb_class_new_instance(2, point_args, Lowess_Point);
+  }
+
+  rb_ary_cat(ret, points, len);
+
+  xfree(points);
+  xfree(res);
+  xfree(rw);
+  xfree(out_ys);
+  xfree(ys);
+  xfree(xs);
+
+  return ret;
+}
+
+void Init_ext_lowess() {
+  X = rb_intern("@x");
+  Y = rb_intern("@y");
+  Point = rb_intern("Point");
+
+  Lowess = rb_define_module("Lowess");
+  Lowess_Point = rb_const_get(Lowess, Point);
+
+  rb_define_singleton_method(Lowess, "ext_lowess", lowess_ext_lowess, 4);
+}

data/lib/lowess.rb

@@ -0,0 +1,29 @@
+# A LOWESS smoother
+module Lowess
+  # Smooths the input points
+  #
+  # Arguments:
+  #
+  # * points: Array of Lowess::Point objects, in any order.
+  # * options: any of:
+  #   * f: the smoother span. Larger values give more smoothness.
+  #   * iter: the number of 'robustifying' iterations. Smaller is faster.
+  #   * delta: minimum x distance between input points. Larger is faster.
+  #
+  # See https://stat.ethz.ch/R-manual/R-devel/library/stats/html/lowess.html
+  # for more complete documentation.
+  def self.lowess(points, options={})
+    raise ArgumentError.new("Must pass one or more points") if points.empty?
+
+    sorted_points = points.sort
+
+    f = (options[:f] || 2.0 / 3).to_f
+    iter = (options[:iter] || 3).to_i
+    delta = (options[:delta] || (sorted_points.last.x - sorted_points.first.x).to_f / 100).to_f || 1.0
+
+    ext_lowess(points, f, iter, delta)
+  end
+end
+
+require 'lowess/point'
+require 'ext_lowess'

data/lib/lowess/point.rb

@@ -0,0 +1,22 @@
+class Lowess::Point
+  include Comparable
+
+  attr_reader(:x, :y)
+
+  def initialize(x, y)
+    @x = x.to_f
+    @y = y.to_f
+  end
+
+  def <=>(p2)
+    if x != p2.x
+      x <=> p2.x
+    else
+      y <=> p2.y
+    end
+  end
+
+  def to_s
+    sprintf("(%0.4f, %0.4f)", @x, @y)
+  end
+end

data/lib/lowess/version.rb

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

data/lowess.gemspec

@@ -0,0 +1,23 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'lowess/version'
+
+Gem::Specification.new do |s|
+  s.name = 'lowess'
+  s.version = Lowess::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = [ 'Adam Hooper' ]
+  s.email = [ 'adam@adamhooper.com' ]
+  s.homepage = 'http://rubygems.org/gems/ruby-lowess'
+  s.summary = 'Lowess scatter plot smoothing'
+  s.description = 'Runs the Lowess smoothing algorithm'
+  s.license = 'GPL2'
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- test/*`.split("\n")
+
+  s.require_paths = [ 'lib' ]
+  s.extensions = [ 'ext/ext_lowess/extconf.rb' ]
+
+  s.add_development_dependency 'rake', '~> 11'
+  s.add_development_dependency 'rake-compiler', '~> 0.9'
+end

data/test/test_lowess.rb

@@ -0,0 +1,155 @@
+require 'minitest/autorun'
+require 'lowess'
+
+class LowessTest < Minitest::Test
+  def test_typical_input
+    # R session:
+    #
+    # > x <- c(0, 1, 2, 3, 4)
+    # > y <- c(2, 3, 1, 5, 4)
+    # > lowess(x=x, y=y, f=1)
+    # $x
+    # [1] 0 1 2 3 4
+    #
+    # $y
+    # [1] 2.102895 2.549205 3.183370 3.727202 4.376544
+    #
+    out = Lowess::lowess([ p(0, 2), p(1, 3), p(2, 1), p(3, 5), p(4, 4) ], f: 1)
+    assert_near [ p(0, 2.102895), p(1, 2.549205), p(2, 3.183370), p(3, 3.727202), p(4, 4.376544) ], out
+  end
+
+  def test_zero_inputs
+    # R session:
+    #
+    # > x <- c()
+    # > y <- c()
+    # > lowess(x=x, y=y)
+    # Error in lowess(x, y) : invalid input
+    assert_raises ::ArgumentError do
+      Lowess::lowess([])
+    end
+  end
+
+  def test_one_input
+    # R session:
+    #
+    # > x <- c(0)
+    # > y <- c(1)
+    # > lowess(x=x, y=y)
+    # $x
+    # [1] 0
+    #
+    # $y
+    # [1] 1
+    out = Lowess::lowess([ p(0, 1) ])
+    assert_equal [ p(0, 1) ], out
+  end
+
+  def test_two_inputs
+    # R session:
+    #
+    # > x <- c(0, 1)
+    # > y <- c(0.2, 0.2)
+    # > lowess(x, y)
+    # $x
+    # [1] 0 1
+    #
+    # $y
+    # [1] 0.2 0.2
+    input = [ p(0, 0.2), p(1, 0.2) ]
+    assert_equal input, Lowess::lowess(input)
+  end
+
+  def test_f
+    # R session:
+    #
+    # > x <- c(0, 1, 2, 3, 4)
+    # > y <- c(2, 3, 1, 5, 4)
+    # > lowess(x, y, f=0.8)
+    # $x
+    # [1] 0 1 2 3 4
+    #
+    # $y
+    # [1] 2.314658 2.180697 2.847178 3.562879 4.498597
+    assert_near ps(%w(2.314658 2.180697 2.847178 3.562879 4.498597)), Lowess::lowess(ps([ 2, 3, 1, 5, 4 ]), f: 0.8)
+  end
+
+  def test_iter
+    # R session:
+    #
+    # > x <- c(0, 1, 2, 3, 4)
+    # > y <- c(2, 3, 1, 5, 4)
+    # > lowess(x, y, f=0.8, iter=1)
+    # $x
+    # [1] 0 1 2 3 4
+    #
+    # $y
+    # [1] 2.322932 2.167876 2.809222 3.553910 4.517957
+    assert_near ps(%w(2.322932 2.167876 2.809222 3.553910 4.517957)), Lowess::lowess(ps([ 2, 3, 1, 5, 4 ]), f: 0.8, iter: 1)
+  end
+
+  def test_delta
+    # R session:
+    #
+    # > x <- c(0, 1, 2, 3, 4)
+    # > y <- c(2, 3, 1, 5, 4)
+    # > lowess(x, y, f=0.9, delta=2.0)
+    # $x
+    # [1] 0 1 2 3 4
+    #
+    # $y
+    # [1] 2 3 4 4 4
+    assert_near ps(%w(2 3 4 4 4)), Lowess::lowess(ps([ 2, 3, 1, 5, 4 ]), f: 0.8, delta: 2.0)
+  end
+
+  def test_non_uniform_line
+    # R session:
+    #
+    # > x <- c(1, 1.1, 2, 2, 3)
+    # > y <- c(1.1, 1.2, 2.2, 1.2, 3.1)
+    # > lowess(x, y)
+    # $x
+    # [1] 1.0 1.1 2.0 2.0 3.0
+    #
+    # $y
+    # [1] 1.1 1.2 1.7 1.7 3.1
+    input = [ p(1, 1.1), p(1.1, 1.2), p(2, 2.2), p(2, 1.2), p(3, 3.1) ]
+    expect_output = [ p(1, 1.1), p(1.1, 1.2), p(2, 1.7), p(2, 1.7), p(3, 3.1) ]
+    assert_near expect_output, Lowess::lowess(input)
+  end
+
+  def test_example_from_readme
+    points = [
+      Lowess::Point.new(1, 1.1),
+      Lowess::Point.new(1.3, 1.3),
+      Lowess::Point.new(1.7, 1.1),
+      Lowess::Point.new(2.1, 1.7)
+    ]
+
+    expect = [ 1, 1.3, 1.7, 2.1 ].zip([ 1.1531, 1.1854, 1.3444, 1.6363]).map { |x, y| Lowess::Point.new(x, y) }
+
+    assert_near expect, Lowess::lowess(points, f: 1.0, iter: 4)
+  end
+
+  private
+
+  def assert_near(pts1, pts2)
+    xs1 = pts1.map { |pt| pt.x.round(4) }
+    xs2 = pts2.map { |pt| pt.x.round(4) }
+    ys1 = pts1.map { |pt| pt.y.round(4) }
+    ys2 = pts2.map { |pt| pt.y.round(4) }
+
+    rounded1 = xs1.zip(ys1).map { |x, y| Lowess::Point.new(x, y) }
+    rounded2 = xs2.zip(ys2).map { |x, y| Lowess::Point.new(x, y) }
+
+    assert_equal rounded1, rounded2
+  end
+
+  def ps(ys)
+    ys.each_with_index.map { |y, i| Lowess::Point.new(i, y) }
+  end
+
+  def p(x, y)
+    Lowess::Point.new(x, y)
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: lowess
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Adam Hooper
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Runs the Lowess smoothing algorithm
+email:
+- adam@adamhooper.com
+executables: []
+extensions:
+- ext/ext_lowess/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- README.md
+- Rakefile
+- ext/ext_lowess/README.md
+- ext/ext_lowess/clowess.c
+- ext/ext_lowess/download_clowess.rb
+- ext/ext_lowess/extconf.rb
+- ext/ext_lowess/lowess.c
+- lib/lowess.rb
+- lib/lowess/point.rb
+- lib/lowess/version.rb
+- lowess.gemspec
+- test/test_lowess.rb
+homepage: http://rubygems.org/gems/ruby-lowess
+licenses:
+- GPL2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Lowess scatter plot smoothing
+test_files:
+- test/test_lowess.rb