stl-rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 27deddcf999b886ec030e044a3875bf175918d6ca417cc3eca23490402526d98
+  data.tar.gz: 9876b7bfde1681a95c1b80b2c9072545d75d967cef1b48dccbff3111f77eb848
+SHA512:
+  metadata.gz: 4675511aa5679abe804a1c53d7914cf236a4e2045dd2cc52211a81a810ec657ce98a520fc89c87b121d0439e1c2e49a0f15233ad6f9c6f3c4143cb3f9db668ab
+  data.tar.gz: 95bdd4d19dd9ebf24acbc0980af10a9438fafbfdf2037140b3a19d3da6bd0fffa55c11356c1d8a0983e06ab08985af9ba79a3a2dfc5c5dd167a53ceb86e8499f

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 (2021-10-16)
+
+- First release

data/README.md

@@ -0,0 +1,102 @@
+# STL Ruby
+
+Seasonal-trend decomposition for Ruby
+
+[![Build Status](https://github.com/ankane/stl-ruby/workflows/build/badge.svg?branch=master)](https://github.com/ankane/stl-ruby/actions)
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'stl-rb'
+```
+
+## Getting Started
+
+Decompose a time series
+
+```ruby
+series = {
+  Date.parse("2020-01-01") => 100,
+  Date.parse("2020-01-02") => 150,
+  Date.parse("2020-01-03") => 136,
+  # ...
+}
+
+Stl.decompose(series, period: 7)
+```
+
+Works great with [Groupdate](https://github.com/ankane/groupdate)
+
+```ruby
+series = User.group_by_day(:created_at).count
+Stl.decompose(series, period: 7)
+```
+
+Series can also be an array without times (the index is returned)
+
+```ruby
+series = [100, 150, 136, ...]
+Stl.decompose(series, period: 7)
+```
+
+Use robustness iterations
+
+```ruby
+Stl.decompose(series, period: 7, robust: true)
+```
+
+## Options
+
+Pass options
+
+```ruby
+Stl.decompose(
+  series,
+  period: 7,              # period of the seasonal component
+  seasonal_length: 7,     # length of the seasonal smoother
+  trend_length: 15,       # length of the trend smoother
+  low_pass_length: 7,     # length of the low-pass filter
+  seasonal_degree: 0,     # degree of locally-fitted polynomial in seasonal smoothing
+  trend_degree: 1,        # degree of locally-fitted polynomial in trend smoothing
+  low_pass_degree: 1,     # degree of locally-fitted polynomial in low-pass smoothing
+  seasonal_jump: 1,       # skipping value for seasonal smoothing
+  trend_jump: 2,          # skipping value for trend smoothing
+  low_pass_jump: 1,       # skipping value for low-pass smoothing
+  inner_loops: 2,         # number of loops for updating the seasonal and trend components
+  outer_loops: 0,         # number of iterations of robust fitting
+  robust: false           # if robustness iterations are to be used
+)
+```
+
+## Credits
+
+This library was ported from the [Fortran implementation](https://www.netlib.org/a/stl).
+
+## References
+
+- [STL: A Seasonal-Trend Decomposition Procedure Based on Loess](https://www.scb.se/contentassets/ca21efb41fee47d293bbee5bf7be7fb3/stl-a-seasonal-trend-decomposition-procedure-based-on-loess.pdf)
+
+## History
+
+View the [changelog](https://github.com/ankane/stl-ruby/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/stl-ruby/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/stl-ruby/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
+
+To get started with development:
+
+```sh
+git clone https://github.com/ankane/stl-ruby.git
+cd stl-ruby
+bundle install
+bundle exec rake compile
+bundle exec rake test
+```

data/ext/stl/ext.cpp

@@ -0,0 +1,48 @@
+// stl
+#include "stl.hpp"
+
+// rice
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+Rice::Array to_a(std::vector<float>& x) {
+  auto a = Rice::Array();
+  for (auto v : x) {
+    a.push(v);
+  }
+  return a;
+}
+
+extern "C"
+void Init_ext() {
+  auto rb_mStl = Rice::define_module("Stl");
+
+  Rice::define_class_under<stl::StlParams>(rb_mStl, "StlParams")
+    .define_constructor(Rice::Constructor<stl::StlParams>())
+    .define_method("seasonal_length", &stl::StlParams::seasonal_length)
+    .define_method("trend_length", &stl::StlParams::trend_length)
+    .define_method("low_pass_length", &stl::StlParams::low_pass_length)
+    .define_method("seasonal_degree", &stl::StlParams::seasonal_degree)
+    .define_method("trend_degree", &stl::StlParams::trend_degree)
+    .define_method("low_pass_degree", &stl::StlParams::low_pass_degree)
+    .define_method("seasonal_jump", &stl::StlParams::seasonal_jump)
+    .define_method("trend_jump", &stl::StlParams::trend_jump)
+    .define_method("low_pass_jump", &stl::StlParams::low_pass_jump)
+    .define_method("inner_loops", &stl::StlParams::inner_loops)
+    .define_method("outer_loops", &stl::StlParams::outer_loops)
+    .define_method("robust", &stl::StlParams::robust)
+    .define_method(
+      "fit",
+      [](stl::StlParams& self, std::vector<float> series, size_t period, bool weights) {
+        auto result = self.fit(series, period);
+
+        auto ret = Rice::Hash();
+        ret[Rice::Symbol("seasonal")] = to_a(result.seasonal);
+        ret[Rice::Symbol("trend")] = to_a(result.trend);
+        ret[Rice::Symbol("remainder")] = to_a(result.remainder);
+        if (weights) {
+          ret[Rice::Symbol("weights")] = to_a(result.weights);
+        }
+        return ret;
+      });
+}

data/ext/stl/extconf.rb

@@ -0,0 +1,5 @@
+require "mkmf-rice"
+
+$CXXFLAGS += " -std=c++17 $(optflags)"
+
+create_makefile("stl/ext")

data/ext/stl/stl.hpp

@@ -0,0 +1,482 @@
+/*!
+ * STL C++ v0.1.0
+ * https://github.com/ankane/stl-cpp
+ * Unlicense OR MIT License
+ *
+ * Ported from https://www.netlib.org/a/stl
+ *
+ * Cleveland, R. B., Cleveland, W. S., McRae, J. E., & Terpenning, I. (1990).
+ * STL: A Seasonal-Trend Decomposition Procedure Based on Loess.
+ * Journal of Official Statistics, 6(1), 3-33.
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <optional>
+#include <stdexcept>
+#include <vector>
+
+namespace stl {
+
+bool est(const float* y, size_t n, size_t len, int ideg, float xs, float* ys, size_t nleft, size_t nright, float* w, bool userw, const float* rw) {
+    auto range = ((float) n) - 1.0;
+    auto h = std::max(xs - ((float) nleft), ((float) nright) - xs);
+
+    if (len > n) {
+        h += (float) ((len - n) / 2);
+    }
+
+    auto h9 = 0.999 * h;
+    auto h1 = 0.001 * h;
+
+    // compute weights
+    auto a = 0.0;
+    for (auto j = nleft; j <= nright; j++) {
+        w[j - 1] = 0.0;
+        auto r = fabs(((float) j) - xs);
+        if (r <= h9) {
+            if (r <= h1) {
+                w[j - 1] = 1.0;
+            } else {
+                w[j - 1] = pow(1.0 - pow(r / h, 3), 3);
+            }
+            if (userw) {
+                w[j - 1] *= rw[j - 1];
+            }
+            a += w[j - 1];
+        }
+    }
+
+    if (a <= 0.0) {
+        return false;
+    } else { // weighted least squares
+        for (auto j = nleft; j <= nright; j++) { // make sum of w(j) == 1
+            w[j - 1] /= a;
+        }
+
+        if (h > 0.0 && ideg > 0) { // use linear fit
+            auto a = 0.0;
+            for (auto j = nleft; j <= nright; j++) { // weighted center of x values
+                a += w[j - 1] * ((float) j);
+            }
+            auto b = xs - a;
+            auto c = 0.0;
+            for (auto j = nleft; j <= nright; j++) {
+                c += w[j - 1] * pow(((float) j) - a, 2);
+            }
+            if (sqrt(c) > 0.001 * range) {
+                b /= c;
+
+                // points are spread out enough to compute slope
+                for (auto j = nleft; j <= nright; j++) {
+                    w[j - 1] *= b * (((float) j) - a) + 1.0;
+                }
+            }
+        }
+
+        *ys = 0.0;
+        for (auto j = nleft; j <= nright; j++) {
+            *ys += w[j - 1] * y[j - 1];
+        }
+
+        return true;
+    }
+}
+
+void ess(const float* y, size_t n, size_t len, int ideg, size_t njump, bool userw, const float* rw, float* ys, float* res) {
+    if (n < 2) {
+        ys[0] = y[0];
+        return;
+    }
+
+    auto nleft = 0;
+    auto nright = 0;
+
+    auto newnj = std::min(njump, n - 1);
+    if (len >= n) {
+        nleft = 1;
+        nright = n;
+        for (auto i = 1; i <= n; i += newnj) {
+            auto ok = est(y, n, len, ideg, (float) i, &ys[i - 1], nleft, nright, res, userw, rw);
+            if (!ok) {
+                ys[i - 1] = y[i - 1];
+            }
+        }
+    } else if (newnj == 1) { // newnj equal to one, len less than n
+        auto nsh = (len + 1) / 2;
+        nleft = 1;
+        nright = len;
+        for (auto i = 1; i <= n; i++) { // fitted value at i
+            if (i > nsh && nright != n) {
+                nleft += 1;
+                nright += 1;
+            }
+            auto ok = est(y, n, len, ideg, (float) i, &ys[i - 1], nleft, nright, res, userw, rw);
+            if (!ok) {
+                ys[i - 1] = y[i - 1];
+            }
+        }
+    } else { // newnj greater than one, len less than n
+        auto nsh = (len + 1) / 2;
+        for (auto i = 1; i <= n; i += newnj) { // fitted value at i
+            if (i < nsh) {
+                nleft = 1;
+                nright = len;
+            } else if (i >= n - nsh + 1) {
+                nleft = n - len + 1;
+                nright = n;
+            } else {
+                nleft = i - nsh + 1;
+                nright = len + i - nsh;
+            }
+            auto ok = est(y, n, len, ideg, (float) i, &ys[i - 1], nleft, nright, res, userw, rw);
+            if (!ok) {
+                ys[i - 1] = y[i - 1];
+            }
+        }
+    }
+
+    if (newnj != 1) {
+        for (auto i = 1; i <= n - newnj; i += newnj) {
+            auto delta = (ys[i + newnj - 1] - ys[i - 1]) / ((float) newnj);
+            for (auto j = i + 1; j <= i + newnj - 1; j++) {
+                ys[j - 1] = ys[i - 1] + delta * ((float) (j - i));
+            }
+        }
+        auto k = ((n - 1) / newnj) * newnj + 1;
+        if (k != n) {
+            auto ok = est(y, n, len, ideg, (float) n, &ys[n - 1], nleft, nright, res, userw, rw);
+            if (!ok) {
+                ys[n - 1] = y[n - 1];
+                if (k != n - 1) {
+                    auto delta = (ys[n - 1] - ys[k - 1]) / ((float) (n - k));
+                    for (auto j = k + 1; j <= n - 1; j++) {
+                        ys[j - 1] = ys[k - 1] + delta * ((float) (j - k));
+                    }
+                }
+            }
+        }
+    }
+}
+
+void ma(const float* x, size_t n, size_t len, float* ave) {
+    auto newn = n - len + 1;
+    auto flen = (float) len;
+    auto v = 0.0;
+
+    // get the first average
+    for (auto i = 0; i < len; i++) {
+        v += x[i];
+    }
+
+    ave[0] = v / flen;
+    if (newn > 1) {
+        auto k = len;
+        auto m = 0;
+        for (auto j = 1; j < newn; j++) {
+            // window down the array
+            v = v - x[m] + x[k];
+            ave[j] = v / flen;
+            k += 1;
+            m += 1;
+        }
+    }
+}
+
+void fts(const float* x, size_t n, size_t np, float* trend, float* work) {
+    ma(x, n, np, trend);
+    ma(trend, n - np + 1, np, work);
+    ma(work, n - 2 * np + 2, 3, trend);
+}
+
+void rwts(const float* y, size_t n, const float* fit, float* rw) {
+    for (auto i = 0; i < n; i++) {
+        rw[i] = fabs(y[i] - fit[i]);
+    }
+
+    auto mid1 = (n - 1) / 2;
+    auto mid2 = n / 2;
+
+    // sort
+    std::sort(rw, rw + n);
+
+    auto cmad = 3.0 * (rw[mid1] + rw[mid2]); // 6 * median abs resid
+    auto c9 = 0.999 * cmad;
+    auto c1 = 0.001 * cmad;
+
+    for (auto i = 0; i < n; i++) {
+        auto r = fabs(y[i] - fit[i]);
+        if (r <= c1) {
+            rw[i] = 1.0;
+        } else if (r <= c9) {
+            rw[i] = pow(1.0 - pow(r / cmad, 2), 2);
+        } else {
+            rw[i] = 0.0;
+        }
+    }
+}
+
+void ss(const float* y, size_t n, size_t np, size_t ns, int isdeg, size_t nsjump, bool userw, float* rw, float* season, float* work1, float* work2, float* work3, float* work4) {
+    for (auto j = 1; j <= np; j++) {
+        auto k = (n - j) / np + 1;
+
+        for (auto i = 1; i <= k; i++) {
+            work1[i - 1] = y[(i - 1) * np + j - 1];
+        }
+        if (userw) {
+            for (auto i = 1; i <= k; i++) {
+                work3[i - 1] = rw[(i - 1) * np + j - 1];
+            }
+        }
+        ess(work1, k, ns, isdeg, nsjump, userw, work3, work2 + 1, work4);
+        auto xs = 0.0;
+        auto nright = std::min(ns, k);
+        auto ok = est(work1, k, ns, isdeg, xs, &work2[0], 1, nright, work4, userw, work3);
+        if (!ok) {
+            work2[0] = work2[1];
+        }
+        xs = k + 1;
+        size_t nleft = std::max(1, (int) k - (int) ns + 1);
+        ok = est(work1, k, ns, isdeg, xs, &work2[k + 1], nleft, k, work4, userw, work3);
+        if (!ok) {
+            work2[k + 1] = work2[k];
+        }
+        for (auto m = 1; m <= k + 2; m++) {
+            season[(m - 1) * np + j - 1] = work2[m - 1];
+        }
+    }
+}
+
+void onestp(const float* y, size_t n, size_t np, size_t ns, size_t nt, size_t nl, int isdeg, int itdeg, int ildeg, size_t nsjump, size_t ntjump, size_t nljump, size_t ni, bool userw, float* rw, float* season, float* trend, float* work1, float* work2, float* work3, float* work4, float* work5) {
+    for (auto j = 0; j < ni; j++) {
+        for (auto i = 0; i < n; i++) {
+            work1[i] = y[i] - trend[i];
+        }
+
+        ss(work1, n, np, ns, isdeg, nsjump, userw, rw, work2, work3, work4, work5, season);
+        fts(work2, n + 2 * np, np, work3, work1);
+        ess(work3, n, nl, ildeg, nljump, false, work4, work1, work5);
+        for (auto i = 0; i < n; i++) {
+            season[i] = work2[np + i] - work1[i];
+        }
+        for (auto i = 0; i < n; i++) {
+            work1[i] = y[i] - season[i];
+        }
+        ess(work1, n, nt, itdeg, ntjump, userw, rw, trend, work3);
+    }
+}
+
+void stl(const float* y, size_t n, size_t np, size_t ns, size_t nt, size_t nl, int isdeg, int itdeg, int ildeg, size_t nsjump, size_t ntjump, size_t nljump, size_t ni, size_t no, float* rw, float* season, float* trend) {
+    auto work1 = std::vector<float>(n + 2 * np);
+    auto work2 = std::vector<float>(n + 2 * np);
+    auto work3 = std::vector<float>(n + 2 * np);
+    auto work4 = std::vector<float>(n + 2 * np);
+    auto work5 = std::vector<float>(n + 2 * np);
+
+    auto userw = false;
+    auto k = 0;
+
+    if (ns < 3) {
+        throw std::invalid_argument("seasonal_length must be at least 3");
+    }
+    if (nt < 3) {
+        throw std::invalid_argument("trend_length must be at least 3");
+    }
+    if (nl < 3) {
+        throw std::invalid_argument("low_pass_length must be at least 3");
+    }
+    if (np < 2) {
+        throw std::invalid_argument("period must be at least 2");
+    }
+
+    if (isdeg != 0 && isdeg != 1) {
+        throw std::invalid_argument("seasonal_degree must be 0 or 1");
+    }
+    if (itdeg != 0 && itdeg != 1) {
+        throw std::invalid_argument("trend_degree must be 0 or 1");
+    }
+    if (ildeg != 0 && ildeg != 1) {
+        throw std::invalid_argument("low_pass_degree must be 0 or 1");
+    }
+
+    if (ns % 2 != 1) {
+        throw std::invalid_argument("seasonal_length must be odd");
+    }
+    if (nt % 2 != 1) {
+        throw std::invalid_argument("trend_length must be odd");
+    }
+    if (nl % 2 != 1) {
+        throw std::invalid_argument("low_pass_length must be odd");
+    }
+
+    while (true) {
+        onestp(y, n, np, ns, nt, nl, isdeg, itdeg, ildeg, nsjump, ntjump, nljump, ni, userw, rw, season, trend, work1.data(), work2.data(), work3.data(), work4.data(), work5.data());
+        k += 1;
+        if (k > no) {
+            break;
+        }
+        for (auto i = 0; i < n; i++) {
+            work1[i] = trend[i] + season[i];
+        }
+        rwts(y, n, work1.data(), rw);
+        userw = true;
+    }
+
+    if (no <= 0) {
+        for (auto i = 0; i < n; i++) {
+            rw[i] = 1.0;
+        }
+    }
+}
+
+class StlResult {
+public:
+    std::vector<float> seasonal;
+    std::vector<float> trend;
+    std::vector<float> remainder;
+    std::vector<float> weights;
+};
+
+class StlParams {
+    std::optional<size_t> ns_ = std::nullopt;
+    std::optional<size_t> nt_ = std::nullopt;
+    std::optional<size_t> nl_ = std::nullopt;
+    int isdeg_ = 0;
+    int itdeg_ = 1;
+    std::optional<int> ildeg_ = std::nullopt;
+    std::optional<size_t> nsjump_ = std::nullopt;
+    std::optional<size_t> ntjump_ = std::nullopt;
+    std::optional<size_t> nljump_ = std::nullopt;
+    std::optional<size_t> ni_ = std::nullopt;
+    std::optional<size_t> no_ = std::nullopt;
+    bool robust_ = false;
+
+public:
+    inline StlParams seasonal_length(size_t ns) {
+        this->ns_ = ns;
+        return *this;
+    };
+
+    inline StlParams trend_length(size_t nt) {
+        this->nt_ = nt;
+        return *this;
+    };
+
+    inline StlParams low_pass_length(size_t nl) {
+        this->nl_ = nl;
+        return *this;
+    };
+
+    inline StlParams seasonal_degree(int isdeg) {
+        this->isdeg_ = isdeg;
+        return *this;
+    };
+
+    inline StlParams trend_degree(int itdeg) {
+        this->itdeg_ = itdeg;
+        return *this;
+    };
+
+    inline StlParams low_pass_degree(int ildeg) {
+        this->ildeg_ = ildeg;
+        return *this;
+    };
+
+    inline StlParams seasonal_jump(size_t nsjump) {
+        this->nsjump_ = nsjump;
+        return *this;
+    };
+
+    inline StlParams trend_jump(size_t ntjump) {
+        this->ntjump_ = ntjump;
+        return *this;
+    };
+
+    inline StlParams low_pass_jump(size_t nljump) {
+        this->nljump_ = nljump;
+        return *this;
+    };
+
+    inline StlParams inner_loops(bool ni) {
+        this->ni_ = ni;
+        return *this;
+    };
+
+    inline StlParams outer_loops(bool no) {
+        this->no_ = no;
+        return *this;
+    };
+
+    inline StlParams robust(bool robust) {
+        this->robust_ = robust;
+        return *this;
+    };
+
+    StlResult fit(const float* y, size_t n, size_t np);
+    StlResult fit(const std::vector<float>& y, size_t np);
+};
+
+StlParams params() {
+    return StlParams();
+}
+
+StlResult StlParams::fit(const float* y, size_t n, size_t np) {
+    if (n < 2 * np) {
+        throw std::invalid_argument("series has less than two periods");
+    }
+
+    auto ns = this->ns_.value_or(np);
+
+    auto isdeg = this->isdeg_;
+    auto itdeg = this->itdeg_;
+
+    auto res = StlResult {
+        std::vector<float>(n),
+        std::vector<float>(n),
+        std::vector<float>(),
+        std::vector<float>(n)
+    };
+
+    auto ildeg = this->ildeg_.value_or(itdeg);
+    auto newns = std::max(ns, (size_t) 3);
+    if (newns % 2 == 0) {
+        newns += 1;
+    }
+
+    auto newnp = std::max(np, (size_t) 2);
+    auto nt = (size_t) ceil((1.5 * newnp) / (1.0 - 1.5 / (float) newns));
+    nt = this->nt_.value_or(nt);
+    nt = std::max(nt, (size_t) 3);
+    if (nt % 2 == 0) {
+        nt += 1;
+    }
+
+    auto nl = this->nl_.value_or(newnp);
+    if (nl % 2 == 0 && !this->nl_.has_value()) {
+        nl += 1;
+    }
+
+    auto ni = this->ni_.value_or(this->robust_ ? 1 : 2);
+    auto no = this->no_.value_or(this->robust_ ? 15 : 0);
+
+    auto nsjump = this->nsjump_.value_or((size_t) ceil(((float) newns) / 10.0));
+    auto ntjump = this->ntjump_.value_or((size_t) ceil(((float) nt) / 10.0));
+    auto nljump = this->nljump_.value_or((size_t) ceil(((float) nl) / 10.0));
+
+    stl(y, n, newnp, newns, nt, nl, isdeg, itdeg, ildeg, nsjump, ntjump, nljump, ni, no, res.weights.data(), res.seasonal.data(), res.trend.data());
+
+    res.remainder.reserve(n);
+    for (auto i = 0; i < n; i++) {
+        res.remainder.push_back(y[i] - res.seasonal[i] - res.trend[i]);
+    }
+
+    return res;
+}
+
+StlResult StlParams::fit(const std::vector<float>& y, size_t np) {
+    return StlParams::fit(y.data(), y.size(), np);
+}
+
+}

data/lib/stl/version.rb

@@ -0,0 +1,3 @@
+module Stl
+  VERSION = "0.1.0"
+end

data/lib/stl-rb.rb

@@ -0,0 +1 @@
+require "stl"

data/lib/stl.rb

@@ -0,0 +1,42 @@
+# ext
+require "stl/ext"
+
+# modules
+require "stl/version"
+
+module Stl
+  def self.decompose(
+    series, period:,
+    seasonal_length: nil, trend_length: nil, low_pass_length: nil,
+    seasonal_degree: nil, trend_degree: nil, low_pass_degree: nil,
+    seasonal_jump: nil, trend_jump: nil, low_pass_jump: nil,
+    inner_loops: nil, outer_loops: nil, robust: false
+  )
+    params = StlParams.new
+
+    params.seasonal_length(seasonal_length) unless seasonal_length.nil?
+    params.trend_length(trend_length) unless trend_length.nil?
+    params.low_pass_length(low_pass_length) unless low_pass_length.nil?
+
+    params.seasonal_degree(seasonal_degree) unless seasonal_degree.nil?
+    params.trend_degree(trend_degree) unless trend_degree.nil?
+    params.low_pass_degree(low_pass_degree) unless low_pass_degree.nil?
+
+    params.seasonal_jump(seasonal_jump) unless seasonal_jump.nil?
+    params.trend_jump(trend_jump) unless trend_jump.nil?
+    params.low_pass_jump(low_pass_jump) unless low_pass_jump.nil?
+
+    params.inner_loops(inner_loops) unless inner_loops.nil?
+    params.outer_loops(outer_loops) unless outer_loops.nil?
+    params.robust(robust) unless robust.nil?
+
+    if series.is_a?(Hash)
+      sorted = series.sort_by { |k, _| k }
+      y = sorted.map(&:last)
+    else
+      y = series
+    end
+
+    params.fit(y, period, outer_loops.nil? ? robust : outer_loops > 0)
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: stl-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Kane
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rice
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.2
+description:
+email: andrew@ankane.org
+executables: []
+extensions:
+- ext/stl/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- ext/stl/ext.cpp
+- ext/stl/extconf.rb
+- ext/stl/stl.hpp
+- lib/stl-rb.rb
+- lib/stl.rb
+- lib/stl/version.rb
+homepage: https://github.com/ankane/stl-ruby
+licenses:
+- Unlicense OR MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: Seasonal-trend decomposition for Ruby
+test_files: []