benchmark-trend 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3396e746a6b1b03c60abcfce59c39bf7ad59eb182092b6900bd5cef6d9a21b8d
+  data.tar.gz: b6dc71b8aa5aa02dd45d6cfe4e3c423006c0aa153573a84f1f476d13dbee5b57
+SHA512:
+  metadata.gz: 03466650b2858047f192477c9c69e9d4f41b27ca6138acfed84f6ef2024346672b3b7d087aabd85d8259c24d858410e6b8efaa05d4669a607a70d824136295c7
+  data.tar.gz: 8036b5662f6392c6b13a9d8d69a03b700294e909f1496de46c8582a95fbdcbcf6d62b61e901d6af1b659e2056d5e724d185ab2c061dc3750d32c7857de9c9843

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Change log
+
+## [v0.1.0] - 2018-09-08
+
+* Inital implementation and release
+
+[v0.1.0]: https://github.com/piotrmurach/benchmark-trend/compare/v0.1.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Piotr Murach
+
+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/README.md

@@ -0,0 +1,287 @@
+# Benchmark::Trend
+
+[![Gem Version](https://badge.fury.io/rb/benchmark-trend.svg)][gem]
+[![Build Status](https://secure.travis-ci.org/piotrmurach/benchmark-trend.svg?branch=master)][travis]
+[![Build status](https://ci.appveyor.com/api/projects/status/798apneaa8ixg5dk?svg=true)][appveyor]
+[![Maintainability](https://api.codeclimate.com/v1/badges/782faa4a8a4662c86792/maintainability)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/github/piotrmurach/benchmark-trend/badge.svg?branch=master)][coverage]
+[![Inline docs](http://inch-ci.org/github/piotrmurach/benchmark-trend.svg?branch=master)][inchpages]
+
+[gem]: http://badge.fury.io/rb/benchmark-trend
+[travis]: http://travis-ci.org/piotrmurach/benchmark-trend
+[appveyor]: https://ci.appveyor.com/project/piotrmurach/benchmark-trend
+[codeclimate]: https://codeclimate.com/github/piotrmurach/benchmark-trend/maintainability
+[coverage]: https://coveralls.io/github/piotrmurach/benchmark-trend?branch=master
+[inchpages]: http://inch-ci.org/github/piotrmurach/benchmark-trend
+
+> Measure pefromance trends of Ruby code based on the input size distribution.
+
+**Benchmark::Trend** will help you estimate the computational complexity of Ruby code by running it on inputs increasing in size, measuring their execution times, and then fitting these observations into a model that best predicts how a given Ruby code will scale as a function of growing workload.
+
+## Why?
+
+Tests provide safety net that ensures your code works correctly. What you don't know is how fast your code is! How does it scale with different input sizes? Your code may have computational complexity that doens't scale with large workloads. It would be good to know before your application goes into production, wouldn't it?
+
+**Benchmark::Trend** will allow you to uncover performance bugs or confirm that a Ruby code performance scales as expected.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'benchmark-trend'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install benchmark-trend
+
+## Contents
+
+* [1. Usage](#1-usage)
+* [2. API](#2--api)
+  * [2.1 range](#21-range)
+  * [2.2 infer_trend](#22-infer_trend)
+  * [2.3 fit](#23-fit)
+  * [2.4 fit_at](#24-fit_at)
+
+## 1. Usage
+
+Let's assume we would like to find out behaviour of a Fibonnacci algorithm:
+
+```ruby
+def fibonacci(n)
+  n == 1 || n == 0 ? n : fibonacci(n - 1) + fibonacci(n - 2)
+end
+```
+
+To measure the actual complexity of above function, we will use `infer_tren` method and pass it as a first argument an array of integer sizes and a block to execute the method:
+
+```ruby
+numbers = Benchmark::Trend.range(1, 28, ratio: 2)
+
+trend, trends = Benchmark::Trend.infer_trend(numbers) do |n|
+  fibonacci(n)
+end
+```
+
+The return type will provide a best trend name:
+
+```ruby
+print trend
+# => exponential
+```
+
+and a Hash of all the trend data:
+
+```ruby
+print trends
+# =>
+# {:exponential=>
+#   {:trend=>"1.38 * 0.00^x",
+#    :slope=>1.382889711685203,
+#    :intercept=>3.822775903539121e-06,
+#    :residual=>0.9052392775178072},
+#  :power=>
+#   {:trend=>"0.00 * x^2.11",
+#    :slope=>2.4911044372815657e-06,
+#    :intercept=>2.1138475434240918,
+#    :residual=>0.5623418036957115},
+#  :linear=>
+#   {:trend=>"0.00 + -0.01*x",
+#    :slope=>0.0028434594496586007,
+#    :intercept=>-0.01370769842204958,
+#    :residual=>0.7290365425188893},
+#  :logarithmic=>
+#   {:trend=>"0.02 + -0.02*ln(x)",
+#    :slope=>0.01738674709454521,
+#    :intercept=>-0.015489004560847924,
+#    :residual=>0.3982368125757882}}
+```
+
+You can see information for the best trend by passing name into trends hash:
+
+```ruby
+print trends[trend]
+# =>
+# {:trend=>"1.38 * 0.00^x",
+#  :slope=>1.382889711685203,
+#  :intercept=>3.822775903539121e-06,
+#  :residual=>0.9052392775178072},
+```
+
+## 2. API
+
+### 2.1 range
+
+To generate a range of values for testing code fitness use the `range` method. It will generate a geometric sequence of numbers, where intermediate values are powers of range multiplier, by default 8:
+
+```ruby
+Benchmark::Trend.range(8, 8 << 10)
+# => [8, 64, 512, 4096, 8192]
+```
+
+You can change the default sequence power by using `:ratio` keyword:
+
+```ruby
+Benchmark::Trend.range(8, 8 << 10, ratio: 2)
+# => [8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192]
+```
+
+### 2.2 infer_trend
+
+To calculate an asymptotic behaviour of Rub code by inferring its computational complexity use `infer_trend`. This method takes as an argument an array of inputs which can be generated using [range](#21-range). The code to measure needs to be provided inside a block.
+
+For example, let's assume you would like to find out asymptotic behaviour of a Fibonacci algorithm:
+
+```ruby
+def fibonacci(n)
+  n == 1 || n == 0 ? n : fibonacci(n - 1) + fibonacci(n - 2)
+end
+```
+
+You could start by generating a range of inputs in powers of 2:
+
+```ruby
+numbers = Benchmark::Trend.range(1, 32, ratio: 2)
+# => [1, 2, 4, 8, 16, 32]
+```
+
+Then measure the performance of the Fibonacci algorithm for each of the data points and fit the observations into a model to predict behaviour as a function of input size:
+
+```ruby
+trend, trends = Benchmark::Trend.infer_trend(numbers) do |n|
+  fibonacci(n)
+end
+```
+
+The return includes the best fit name:
+
+```ruby
+print trend
+# => exponential
+```
+
+And a Hash of all measurements:
+
+```ruby
+print trends
+# =>
+# {:exponential=>
+#   {:trend=>"1.38 * 0.00^x",
+#    :slope=>1.382889711685203,
+#    :intercept=>3.822775903539121e-06,
+#    :residual=>0.9052392775178072},
+#  :power=>
+#   {:trend=>"0.00 * x^2.11",
+#    :slope=>2.4911044372815657e-06,
+#    :intercept=>2.1138475434240918,
+#    :residual=>0.5623418036957115},
+#  :linear=>
+#   {:trend=>"0.00 + -0.01*x",
+#    :slope=>0.0028434594496586007,
+#    :intercept=>-0.01370769842204958,
+#    :residual=>0.7290365425188893},
+#  :logarithmic=>
+#   {:trend=>"0.02 + -0.02*ln(x)",
+#    :slope=>0.01738674709454521,
+#    :intercept=>-0.015489004560847924,
+#    :residual=>0.3982368125757882}}
+```
+
+In order to retrieve trend data for the best fit do:
+
+```ruby
+print trends[trend]
+# =>
+# {:trend=>"1.38 * 0.00^x",
+#  :slope=>1.382889711685203,
+#  :intercept=>3.822775903539121e-06,
+#  :residual=>0.9052392775178072}
+```
+
+### 2.3 fit
+
+Use `fit` method if you wish to fit arbitrary data into a model with a slope and intercept parameters that minimize the error.
+
+For example, given a set of data points that exhibit linear behaviour:
+
+```ruby
+xs = [1, 2, 3, 4, 5]
+ys = xs.map { |x| 3.0 * x + 1.0 }
+```
+
+Fit the data into a model:
+
+```ruby
+slope, intercept, error = Benchmark::Trend.fit(xs, ys)
+```
+
+And printing the values we get confirmation of the linear behaviour of the data points:
+
+```ruby
+print slope
+# => 3.0
+print intercept
+# => 1.0
+print error
+# => 1.0
+```
+
+### 2.4 fit_at
+
+If you are interestd how a model scales for a given input use `fit_at`. This method expects that there is a fit model generated using [infer_trend](#22-infer_trend).
+
+For example, measuring Fibonacci recursive algorithm we have the following results:
+
+```ruby
+# =>
+{:trend=>"1.38 * 0.00^x",
+ :slope=>1.382889711685203,
+ :intercept=>3.822775903539121e-06,
+ :residual=>0.9052392775178072}
+```
+
+And checking model at input of `50`:
+
+```ruby
+Benchamrk::Trend.fit_at(:exponential, slope: 1.382889711685203, intercept: 3.822775903539121e-06, n: 50)
+# => 41.8558455915123
+```
+
+We can see that Fibonacci with just a number 50 will take around 42 seconds to get the result!
+
+How about Fibonacci with 100 as an input?
+
+```ruby
+Benchamrk::Trend.fit_at(:exponential, slope: 1.382889711685203, intercept: 3.822775903539121e-06, n: 100)
+# => 458282633.9777338
+```
+
+This means Fibonacci recursive algorithm will take about 1.45 year to complete!
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/benchmark-trend. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Benchmark::Trend project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/piotrmurach/benchmark-trend/blob/master/CODE_OF_CONDUCT.md).
+
+## Copyright
+
+Copyright (c) 2018 Piotr Murach. See LICENSE for further details.

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+FileList['tasks/**/*.rake'].each(&method(:import))
+
+desc 'Run all specs'
+task ci: %w[ spec ]
+
+task default: :spec

data/benchmark-trend.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'benchmark/trend/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "benchmark-trend"
+  spec.version       = Benchmark::Trend::VERSION
+  spec.authors       = ["Piotr Murach"]
+  spec.email         = [""]
+
+  spec.summary       = %q{Measure pefromance trends of Ruby code based on the input size distribution.}
+  spec.description   = %q{Benchmark::Trend will help you estimate the computational complexity of Ruby code by running it on inputs increasing in size, measuring their execution times, and then fitting these observations into a model that best predicts how a given Ruby code will scale as a function of growing workload.}
+  spec.homepage      = "https://github.com/piotrmurach/benchmark-trend"
+  spec.license       = "MIT"
+
+  spec.files         = Dir['{lib,spec,examples}/**/*.rb']
+  spec.files        += Dir['{bin,exe,tasks}/*', 'benchmark-trend.gemspec']
+  spec.files        += Dir['README.md', 'CHANGELOG.md', 'LICENSE.txt', 'Rakefile']
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "benchmark/trend"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/bench-trend

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require "benchmark/trend"

data/lib/benchmark-trend.rb

@@ -0,0 +1 @@
+require_relative 'benchmark/trend'

data/lib/benchmark/trend.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+
+require_relative 'trend/version'
+
+module Benchmark
+  module Trend
+    # Change module function visiblity to private
+    #
+    # @api private
+    def self.private_module_function(method)
+      module_function(method)
+      private_class_method(method)
+    end
+
+    # Generate a range of inputs spaced by powers.
+    #
+    # The default range is generated in the multiples of 8.
+    #
+    # @example
+    #   Benchmark::Trend.range(8, 8 << 10)
+    #   # => [8, 64, 512, 4096, 8192]
+    #
+    # @param [Integer] start
+    # @param [Integer] limit
+    # @param [Integer] ratio
+    #
+    # @api public
+    def range(start, limit, ratio: 8)
+      check_greater(start, 0)
+      check_greater(limit, start)
+      check_greater(ratio, 2)
+
+      items = []
+      count = start
+      items << count
+      (limit / ratio).times do
+        count *= ratio
+        break if count >= limit
+        items << count
+      end
+      items << limit if start != limit
+      items
+    end
+    module_function :range
+
+    # Check if expected value is greater than minimum
+    #
+    # @param [Numeric] expected
+    # @param [Numeric] min
+    #
+    # @raise [ArgumentError]
+    #
+    # @api private
+    def check_greater(expected, min)
+      unless expected >= min
+        raise ArgumentError,
+              "Range value: #{expected} needs to be greater than #{min}"
+      end
+    end
+    private_module_function :check_greater
+
+    # Gather times for each input against an algorithm
+    #
+    # @param [Array[Numeric]] data
+    #   the data to run measurements for
+    #
+    # @return [Array[Array, Array]]
+    #
+    # @api public
+    def measure_execution_time(data = nil, &work)
+      inputs = data || range(1, 10_000)
+      times  = []
+
+      inputs.each do |input|
+        GC.start
+        times << ::Benchmark.realtime do
+          work.(input)
+        end
+      end
+      [inputs, times]
+    end
+    module_function :measure_execution_time
+
+    # Finds a line of best fit that approximates linear function
+    #
+    # Function form: y = ax + b
+    #
+    # @param [Array[Numeric]] xs
+    #   the data points along X axis
+    #
+    # @param [Array[Numeric]] ys
+    #   the data points along Y axis
+    #
+    # @return [Numeric, Numeric, Numeric]
+    #   return a slope, b intercept and rr correlation coefficient
+    #
+    # @api public
+    def fit_linear(xs, ys)
+      fit(xs, ys)
+    end
+    module_function :fit_linear
+
+    # Find a line of best fit that approximates logarithmic function
+    #
+    # Model form: y = a*lnx + b
+    #
+    # @param [Array[Numeric]] xs
+    #   the data points along X axis
+    #
+    # @param [Array[Numeric]] ys
+    #   the data points along Y axis
+    #
+    # @return [Numeric, Numeric, Numeric]
+    #   returns a, b, and rr values
+    #
+    # @api public
+    def fit_logarithmic(xs, ys)
+      fit(xs, ys, tran_x: ->(x) { Math.log(x) })
+    end
+    module_function :fit_logarithmic
+
+    alias fit_log fit_logarithmic
+    module_function :fit_log
+
+    # Finds a line of best fit that approxmimates power function
+    #
+    # Function form: y = ax^b
+    #
+    # @return [Numeric, Numeric, Numeric]
+    #   returns a, b, and rr values
+    #
+    # @api public
+    def fit_power(xs, ys)
+      a, b, rr = fit(xs, ys, tran_x: ->(x) { Math.log(x) },
+                             tran_y: ->(y) { Math.log(y) })
+
+      [Math.exp(b), a, rr]
+    end
+    module_function :fit_power
+
+    # Find a line of best fit that approximates exponential function
+    #
+    # Model form: y = ab^x
+    #
+    # @return [Numeric, Numeric, Numeric]
+    #   returns a, b, and rr values
+    #
+    # @api public
+    def fit_exponential(xs, ys)
+      a, b, rr = fit(xs, ys, tran_y: ->(y) { Math.log(y) })
+
+      [Math.exp(a), Math.exp(b), rr]
+    end
+    module_function :fit_exponential
+
+    alias fit_exp fit_exponential
+    module_function :fit_exp
+
+    # Fit the performance measurements to construct a model with
+    # slope and intercept parameters that minimize the error.
+    #
+    # @param [Array[Numeric]] xs
+    #   the data points along X axis
+    #
+    # @param [Array[Numeric]] ys
+    #   the data points along Y axis
+    #
+    # @return [Array[Numeric, Numeric, Numeric]
+    #   returns slope, intercept and model's goodness-of-fit
+    #
+    # @api public
+    def fit(xs, ys, tran_x: ->(x) { x }, tran_y: ->(y) { y })
+      eps    = 0.000001
+      n      = 0
+      sum_x  = 0.0
+      sum_x2 = 0.0
+      sum_y  = 0.0
+      sum_y2 = 0.0
+      sum_xy = 0.0
+
+      xs.zip(ys).each do |x, y|
+        n        += 1
+        sum_x    += tran_x.(x)
+        sum_y    += tran_y.(y)
+        sum_x2   += tran_x.(x) ** 2
+        sum_y2   += tran_y.(y) ** 2
+        sum_xy   += tran_x.(x) * tran_y.(y)
+      end
+
+      txy = n * sum_xy - sum_x * sum_y
+      tx  = n * sum_x2 - sum_x ** 2
+      ty  = n * sum_y2 - sum_y ** 2
+
+      if tx.abs < eps # no variation in xs
+        raise ArgumentError, "No variation in data #{xs}"
+      elsif ty.abs < eps # no variation in ys - constant fit
+        slope = 0
+        intercept = sum_y / n
+        residual_sq = 1 # doesn't exist
+      else
+        slope       = txy / tx
+        intercept   = (sum_y - slope * sum_x) / n
+        residual_sq = (txy ** 2) / (tx * ty)
+      end
+
+      [slope, intercept, residual_sq]
+    end
+    module_function :fit
+
+    # Take a fit and estimate behaviour at input size n
+    #
+    # @example
+    #   fit_at(:power, slope: 1.5, intercept: 2, n: 10)
+    #
+    # @return
+    #   fit model value for input n
+    #
+    # @api public
+    def fit_at(type, slope: nil, intercept: nil, n: nil)
+      raise ArgumentError, "Incorrect input size: #{n}" unless n > 0
+
+      case type
+      when :logarithmic, :log
+        intercept + slope * Math.log(n)
+      when :linear
+        intercept + slope * n
+      when :power
+        intercept * (n ** slope)
+      when :exponential, :exp
+        intercept * (slope ** n)
+      else
+        raise ArgumentError, "Unknown fit type: #{type}"
+      end
+    end
+    module_function :fit_at
+
+    # A mathematical notation template for a trend type
+    #
+    # @param [String] type
+    #   the fit model type
+    #
+    # @return [String]
+    #   the formatted mathematical function template
+    #
+    # @api private
+    def format_fit(type)
+      case type
+      when :logarithmic, :log
+        "%.2f + %.2f*ln(x)"
+      when :linear
+        "%.2f + %.2f*x"
+      when :power
+        "%.2f * x^%.2f"
+      when :exponential, :exp
+        "%.2f * %.2f^x"
+      else
+        raise ArgumentError, "Unknown type: '#{type}'"
+      end
+    end
+    module_function :format_fit
+
+    # the trends to consider
+    FIT_TYPES = [:exponential, :power, :linear, :logarithmic]
+
+    # Infer trend from the execution times
+    #
+    # Fits the executiom times for each range to several fit models.
+    #
+    # @yieldparam work
+    #
+    # @return [Array[Symbol, Hash]]
+    #   the best fitting and all the trends
+    #
+    # @api public
+    def infer_trend(data, &work)
+      ns, times = *measure_execution_time(data, &work)
+      best_fit = :none
+      best_residual = 0
+      fitted = {}
+      n = ns.size.to_f
+      aic = -1.0/0
+      best_aic = -1.0/0
+
+      FIT_TYPES.each do |fit|
+        a, b, rr = *send(:"fit_#{fit}", ns, times)
+        # goodness of model
+        aic = n * (Math.log(Math::PI) + 1) + n * Math.log(rr / n)
+        fitted[fit] = { trend: format_fit(fit) % [a, b],
+                        slope: a, intercept: b, residual: rr }
+        if rr > best_residual && aic > best_aic
+          best_residual = rr
+          best_fit = fit
+          best_aic = aic
+        end
+      end
+
+      [best_fit, fitted]
+    end
+    module_function :infer_trend
+  end # Trend
+end # Benchmark

data/lib/benchmark/trend/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Benchmark
+  module Trend
+    VERSION = "0.1.0"
+  end # Trend
+end # Benchmark

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+if ENV['COVERAGE'] || ENV['TRAVIS']
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name 'spec'
+    add_filter 'spec'
+  end
+end
+
+require "bundler/setup"
+require "benchmark/trend"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/unit/fit_at_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+RSpec.describe Benchmark::Trend, '#fit_at' do
+  it "evalutes logarithmic fit model at a given value" do
+    val = Benchmark::Trend.fit_at(:logarithmic, slope: 1.5, intercept: 2, n: 10)
+
+    expect(val).to be_within(0.1).of(5.45)
+  end
+
+  it "evalutes linear fit model at a given value" do
+    val = Benchmark::Trend.fit_at(:linear, slope: 1.5, intercept: 2, n: 10)
+
+    expect(val).to eq(17)
+  end
+
+  it "evalutes power fit model at a given value" do
+    val = Benchmark::Trend.fit_at(:power, slope: 1.5, intercept: 2, n: 10)
+
+    expect(val).to be_within(0.1).of(63.24)
+  end
+
+  it "evalutes power fit model at a given value" do
+    val = Benchmark::Trend.fit_at(:exponential, slope: 1.5, intercept: 2, n: 10)
+
+    expect(val).to be_within(0.1).of(115.33)
+  end
+
+  it "doesn't recognise fit model" do
+    expect {
+      Benchmark::Trend.fit_at(:unknown, slope: 1.5, intercept: 2, n: 10)
+    }.to raise_error(ArgumentError, "Unknown fit type: unknown")
+  end
+
+  it "doesn't allow incorrect input size" do
+    expect {
+      Benchmark::Trend.fit_at(:linear, slope: 1.5, intercept: 2, n: -1)
+    }.to raise_error(ArgumentError, "Incorrect input size: -1")
+  end
+end

data/spec/unit/fit_exp_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+RSpec.describe Benchmark::Trend, '#fit_exp' do
+  it "calculates a perfect exponential fit" do
+    xs = [1, 2, 3, 4, 5]
+    ys = xs.map { |x| 1.5 * (2 ** x) }
+
+    a, b, rr = Benchmark::Trend.fit_exp(xs, ys)
+
+    expect(a).to be_within(0.001).of(2.0)
+    expect(b).to be_within(0.001).of(1.5)
+    expect(rr).to be_within(0.001).of(0.999)
+  end
+
+  it "calculates best exponential fit of y = 1.30*(1.46)^x" do
+    # the number y (in millions) of mobiles subscriberes from 1988 to 1997 USA
+    xs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    ys = [1.6, 2.7, 4.4, 6.4, 8.9, 13.1, 19.3, 28.2, 38.2, 48.7]
+
+    a, b, rr = Benchmark::Trend.fit_exp(xs, ys)
+
+    expect(a).to be_within(0.001).of(1.458)
+    expect(b).to be_within(0.001).of(1.300)
+    expect(rr).to be_within(0.001).of(0.993)
+  end
+end

data/spec/unit/fit_linear_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+RSpec.describe Benchmark::Trend, '#fit_linear' do
+  it "calculates perfect linear fit" do
+    xs = [1, 2, 3, 4, 5]
+    ys = xs.map { |x| 3.0 * x + 1.0 }
+
+    a, b, rr = Benchmark::Trend.fit_linear(xs, ys)
+
+    expect(a).to eq(3.0)
+    expect(b).to eq(1.0)
+    expect(rr).to be_within(0.1).of(1)
+  end
+
+  it "calculates linear fit with noise" do
+    xs = [3.4, 3.8, 4.1, 2.2, 2.6, 2.9, 2.0, 2.7, 1.9, 3.4]
+    ys = [5.5, 5.9, 6.5, 3.3, 3.6, 4.6, 2.9, 3.6, 3.1, 4.9]
+
+    a, b, rr = Benchmark::Trend.fit_linear(xs, ys)
+
+    expect(a).to be_within(0.1).of(1.64)
+    expect(b).to be_within(0.1).of(-0.36)
+    expect(rr).to be_within(0.001).of(0.953)
+  end
+
+  it "calculates perfect constant fit" do
+    xs = [1, 2, 3, 4, 5]
+    ys = [6.0, 6.0, 6.0, 6.0, 6.0]
+
+    a, b, rr = Benchmark::Trend.fit_linear(xs, ys)
+
+    expect(a).to eq(0)
+    expect(b).to eq(6)
+    expect(rr).to eq(1)
+  end
+
+  it "calculates constant fit with noise" do
+    xs = [1, 2, 3, 4, 5]
+    ys = [1.0, 0.9, 1.0, 1.1, 1.0]
+
+    a, b, rr = Benchmark::Trend.fit_linear(xs, ys)
+
+    expect(a).to eq(0.02)
+    expect(b).to be_within(0.01).of(0.94)
+    expect(rr).to be_within(0.01).of(0.19)
+  end
+
+  it "raises when no variation in data" do
+    xs = [1, 1, 1, 1, 1]
+    ys = [1.0, 0.9, 1.0, 1.1, 1.0]
+
+    expect {
+      Benchmark::Trend.fit_linear(xs, ys)
+    }.to raise_error(ArgumentError, "No variation in data [1, 1, 1, 1, 1]")
+  end
+end

data/spec/unit/fit_log_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+RSpec.describe Benchmark::Trend, '#fit_log' do
+  it "calculates perfect logarithmic fit" do
+    xs = [1, 2, 3, 4, 5]
+    ys = xs.map { |x|  1.5 * Math.log(x) + 1.0 }
+
+    a, b, rr = Benchmark::Trend.fit_log(xs, ys)
+
+    expect(a).to be_within(0.001).of(1.5)
+    expect(b).to be_within(0.001).of(1.0)
+    expect(rr).to be_within(0.001).of(1)
+  end
+
+  it "calculates logarithmic fit with noise" do
+    # life expectancy in USA data from 1900 in 10 years periods
+    xs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+    ys = [47.3, 50.0, 54.1, 59.7, 62.9, 68.2, 69.7, 70.8, 73.7, 75.4, 76.8, 78.7]
+
+    a, b, rr = Benchmark::Trend.fit_log(xs, ys)
+
+    expect(a).to be_within(0.001).of(13.857)
+    expect(b).to be_within(0.001).of(42.527)
+    expect(rr).to be_within(0.001).of(0.956)
+  end
+end

data/spec/unit/fit_power_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+RSpec.describe Benchmark::Trend, '#fit_power' do
+  it 'calculates perfect power fit' do
+    xs = [1, 2, 3, 4, 5]
+    ys = xs.map { |x| 1.5*(x ** 2) }
+
+    a, b, rr = Benchmark::Trend.fit_power(xs, ys)
+
+    expect(a).to be_within(0.001).of(1.5)
+    expect(b).to be_within(0.001).of(2.0)
+    expect(rr).to be_within(0.001).of(1.0)
+  end
+
+  it "calcualtes best power fit of y = x^1.5" do
+    #    Mercury Venus Earth  Mars  Jupiter Saturn
+    xs = [0.387, 0.723, 1.00, 1.524, 5.203,  9.539]  # distance from the sun
+    ys = [0.241, 0.615, 1.00, 1.881, 11.862, 29.458] # period in Earth's years
+
+    a, b, rr = Benchmark::Trend.fit_power(xs, ys)
+
+    expect(a).to be_within(0.001).of(1.0)
+    expect(b).to be_within(0.001).of(1.5)
+    expect(rr).to be_within(0.001).of(0.999)
+  end
+end

data/spec/unit/format_fit_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+RSpec.describe Benchmark::Trend, '#format_fit' do
+  it "returns a logarithmic template" do
+    format = Benchmark::Trend.format_fit(:logarithmic)
+    expect(format).to eq("%.2f + %.2f*ln(x)")
+  end
+
+  it "returns a linear template" do
+    format = Benchmark::Trend.format_fit(:linear)
+    expect(format).to eq("%.2f + %.2f*x")
+  end
+
+  it "returns a power template" do
+    format = Benchmark::Trend.format_fit(:power)
+    expect(format).to eq("%.2f * x^%.2f")
+  end
+
+  it "returns a exponential template" do
+    format = Benchmark::Trend.format_fit(:exponential)
+    expect(format).to eq("%.2f * %.2f^x")
+  end
+
+  it "fails to recognise fit type" do
+    expect {
+      Benchmark::Trend.format_fit(:unknown)
+    }.to raise_error(ArgumentError, "Unknown type: 'unknown'")
+  end
+end

data/spec/unit/infer_trend_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+RSpec.describe Benchmark::Trend, '#infer_trend' do
+  # exponential
+  def fibonacci(n)
+    n == 1 || n == 0 ? n : fibonacci(n - 1) + fibonacci(n - 2)
+  end
+
+  # linear
+  def fib_mem(n, acc = {"0" => 0, "1" => 1})
+    return n if n < 2
+
+    if !acc.key?(n.to_s)
+      acc[n.to_s] = fib_mem(n - 1, acc) + fib_mem(n - 2, acc)
+    end
+    acc[n.to_s]
+  end
+
+  # linear
+  def fib_iter(n)
+    a, b = 0, 1
+    n.times { a, b = b, a + b}
+    a
+  end
+
+  # constant
+  def fib_const(n)
+    phi = (1 + Math.sqrt(5))/2
+    (phi ** n / Math.sqrt(5)).round
+  end
+
+  it "infers fibonacci classic algorithm trend to be exponential" do
+    numbers = Benchmark::Trend.range(1, 28, ratio: 2)
+    trend, trends = Benchmark::Trend.infer_trend(numbers) do |n|
+      fibonacci(n)
+    end
+
+    expect(trend).to eq(:exponential)
+    expect(trends).to match(
+      hash_including(:exponential, :power, :linear, :logarithmic))
+    expect(trends[:exponential]).to match(
+      hash_including(:trend, :slope, :intercept, :residual)
+    )
+  end
+
+  it "infers fibonacci iterative algorithm trend to be linear" do
+    numbers = Benchmark::Trend.range(1, 20_000)
+    trend, _ = Benchmark::Trend.infer_trend(numbers) do |n|
+      fib_iter(n)
+    end
+
+    expect(trend).to eq(:linear)
+  end
+
+  it "infers fibonacci constant algorithm trend to be linear" do
+    numbers = Benchmark::Trend.range(1, 500)
+    trend, trends = Benchmark::Trend.infer_trend(numbers) do |n|
+      fib_const(n)
+    end
+
+    expect(trend).to eq(:linear)
+    expect(trends[trend][:slope]).to eq(0)
+  end
+
+  it "infers finding maximum value trend to be linear" do
+    array_sizes = Benchmark::Trend.range(1, 100_000)
+    number_arrays = array_sizes.map { |n| Array.new(n) { rand(n) } }.each
+
+    trend, trends = Benchmark::Trend.infer_trend(array_sizes) do
+      number_arrays.next.max
+    end
+
+    expect(trend).to eq(:linear)
+    expect(trends).to match(
+      hash_including(:exponential, :power, :linear, :logarithmic))
+    expect(trends[:exponential]).to match(
+      hash_including(:trend, :slope, :intercept, :residual)
+    )
+  end
+end

data/spec/unit/measure_execution_time_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+#
+RSpec.describe Benchmark::Trend, "#measure_execution_time" do
+  it "measures performance times" do
+    func = -> (x) { x ** 2 }
+
+    data = Benchmark::Trend.measure_execution_time(&func)
+
+    expect(data[0]).to eq([1, 8, 64, 512, 4096, 10000])
+    expect(data[1]).to match([
+      be_within(0.001).of(0.00001),
+      be_within(0.001).of(0.00001),
+      be_within(0.001).of(0.00001),
+      be_within(0.001).of(0.00001),
+      be_within(0.001).of(0.00001),
+      be_within(0.001).of(0.00001)
+    ])
+  end
+end

data/spec/unit/range_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+RSpec.describe Benchmark::Trend, '#range' do
+  it "creates default range" do
+    range = Benchmark::Trend.range(8, 8 << 10)
+    expect(range).to eq([8, 64, 512, 4096, 8192])
+  end
+
+  it "creates range with 2 multiplier" do
+    range = Benchmark::Trend.range(8, 8 << 10, ratio: 2)
+    expect(range).to eq([8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192])
+  end
+
+  it "checks range start to be valid" do
+    expect { 
+      Benchmark::Trend.range(-2, 10_000)
+    }.to raise_error(ArgumentError, "Range value: -2 needs to be greater than 0")
+  end
+
+  it "checks range end to be greater than start" do
+    expect { 
+      Benchmark::Trend.range(8, 2)
+    }.to raise_error(ArgumentError, "Range value: 2 needs to be greater than 8")
+  end
+
+  it "checks multiplier to be valid" do
+    expect { 
+      Benchmark::Trend.range(8, 32, ratio: 1)
+    }.to raise_error(ArgumentError, "Range value: 1 needs to be greater than 2")
+  end
+end

data/tasks/console.rake

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+desc 'Load gem inside irb console'
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require File.join(__FILE__, '../../lib/benchmark-trend')
+  ARGV.clear
+  IRB.start
+end
+task c: %w[ console ]

data/tasks/coverage.rake

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+desc 'Measure code coverage'
+task :coverage do
+  begin
+    original, ENV['COVERAGE'] = ENV['COVERAGE'], 'true'
+    Rake::Task['spec'].invoke
+  ensure
+    ENV['COVERAGE'] = original
+  end
+end

data/tasks/spec.rake

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+begin
+  require 'rspec/core/rake_task'
+
+  desc 'Run all specs'
+  RSpec::Core::RakeTask.new(:spec) do |task|
+    task.pattern = 'spec/{unit,integration}{,/*/**}/*_spec.rb'
+  end
+
+  namespace :spec do
+    desc 'Run unit specs'
+    RSpec::Core::RakeTask.new(:unit) do |task|
+      task.pattern = 'spec/unit{,/*/**}/*_spec.rb'
+    end
+
+    desc 'Run integration specs'
+    RSpec::Core::RakeTask.new(:integration) do |task|
+      task.pattern = 'spec/integration{,/*/**}/*_spec.rb'
+    end
+  end
+
+rescue LoadError
+  %w[spec spec:unit spec:integration].each do |name|
+    task name do
+      $stderr.puts "In order to run #{name}, do `gem install rspec`"
+    end
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: benchmark-trend
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Piotr Murach
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-09-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Benchmark::Trend will help you estimate the computational complexity
+  of Ruby code by running it on inputs increasing in size, measuring their execution
+  times, and then fitting these observations into a model that best predicts how a
+  given Ruby code will scale as a function of growing workload.
+email:
+- ''
+executables:
+- bench-trend
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark-trend.gemspec
+- bin/console
+- bin/setup
+- exe/bench-trend
+- lib/benchmark-trend.rb
+- lib/benchmark/trend.rb
+- lib/benchmark/trend/version.rb
+- spec/spec_helper.rb
+- spec/unit/fit_at_spec.rb
+- spec/unit/fit_exp_spec.rb
+- spec/unit/fit_linear_spec.rb
+- spec/unit/fit_log_spec.rb
+- spec/unit/fit_power_spec.rb
+- spec/unit/format_fit_spec.rb
+- spec/unit/infer_trend_spec.rb
+- spec/unit/measure_execution_time_spec.rb
+- spec/unit/range_spec.rb
+- tasks/console.rake
+- tasks/coverage.rake
+- tasks/spec.rake
+homepage: https://github.com/piotrmurach/benchmark-trend
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Measure pefromance trends of Ruby code based on the input size distribution.
+test_files: []