philiprehberger-math_kit 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0ee57bd765f6a85f692da57097963ad6a2b24ccb6d3aa72a933f116faf9d7ec
-  data.tar.gz: a07eca98e2878406fb271187fd77e3d5628153ae0e19d74063998510478b631d
+  metadata.gz: 96f9c86935c3a083d2e2a7c7f44f58faf74e8d0bef607c352a82eddfd722b9d8
+  data.tar.gz: 29c3c539be7b4c98b0cacaf6778dd47e3b99ebf0ee8bebd1ffa1aecfcc75b724
 SHA512:
-  metadata.gz: 1c202b40a1dfbd0282d15573433558b0fdacc071a4f33fe7c3cf1547415a3e93a0aa12cd218573069109c659921a97690d3b2a9f8c0b895f573a60c6f651a72e
-  data.tar.gz: 9ce0bf2fa3522a4a9cc922a564ac8102a1b5327e876ed223a43374514809a97311295ed8e5a69dd530ba9634571fbb07ce19b0233ba2067b61d88fbb6a353af1
+  metadata.gz: b511e326737819a0edc160c9bdf9c11dbb940d1dcc0996f4371442d6ec77d9674fcbea55e134d206ab5289858072071f55aeb27eab180bfdcd421335d2d97f75
+  data.tar.gz: b7f1196c85d273cae6a4e0f8bb728c95eecf2e6ced1fae380b9a836cd0078aece475aebe36f9ad8627b428c117c0a6246cee522412607326517bce77455e654f

data/CHANGELOG.md

@@ -7,6 +7,40 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-03-31
+
+### Changed
+- Standardize README badges, support section, and license format
+
+## [0.2.0] - 2026-03-27
+
+### Added
+- Skewness (Fisher-Pearson sample skewness)
+- Kurtosis (excess kurtosis, Fisher definition)
+- Confidence intervals for the mean (90%, 95%, 99% levels with t-distribution)
+- Linear regression with slope, intercept, r-squared, and prediction
+- Pearson correlation coefficient
+- Sample covariance
+- Min-max normalization (normalize to 0..1)
+- Z-score standardization (mean=0, stddev=1)
+- Median absolute deviation (MAD)
+- Trimmed mean with configurable trim fraction
+- Winsorized mean with configurable trim fraction
+- `Regression` module with `Result` data class and `predict` method
+
+## [0.1.2] - 2026-03-26
+
+### Changed
+- Add Sponsor badge to README
+- Fix License section format
+- Sync gemspec summary with README
+
+## [0.1.1] - 2026-03-26
+
+### Changed
+
+- Fix README compliance (one-liner, license link)
+
 ## [0.1.0] - 2026-03-26
 
 ### Added

data/README.md

@@ -2,10 +2,9 @@
 
 [![Tests](https://github.com/philiprehberger/rb-math-kit/actions/workflows/ci.yml/badge.svg)](https://github.com/philiprehberger/rb-math-kit/actions/workflows/ci.yml)
 [![Gem Version](https://badge.fury.io/rb/philiprehberger-math_kit.svg)](https://rubygems.org/gems/philiprehberger-math_kit)
-[![License](https://img.shields.io/github/license/philiprehberger/rb-math-kit)](LICENSE)
-[![Sponsor](https://img.shields.io/badge/sponsor-GitHub%20Sponsors-ec6cb9)](https://github.com/sponsors/philiprehberger)
+[![Last updated](https://img.shields.io/github/last-commit/philiprehberger/rb-math-kit)](https://github.com/philiprehberger/rb-math-kit/commits/main)
 
-Common math and statistics utilities for Ruby. Descriptive statistics, linear interpolation, rounding modes, and moving averages with zero dependencies.
+Statistics, regression, interpolation, rounding modes, and moving averages for Ruby
 
 ## Requirements
 
@@ -44,11 +43,51 @@ Philiprehberger::MathKit::Stats.sum([1, 2, 3])                # => 6
 Philiprehberger::MathKit::Stats.range([1, 5, 3, 9, 2])        # => 8
 ```
 
-Sample variance and standard deviation:
+### Skewness and Kurtosis
 
 ```ruby
-Philiprehberger::MathKit::Stats.variance([2, 4, 4, 4, 5, 5, 7, 9], population: false)  # => 4.571...
-Philiprehberger::MathKit::Stats.stddev([2, 4, 4, 4, 5, 5, 7, 9], population: false)    # => 2.138...
+Philiprehberger::MathKit::Stats.skewness([1, 1, 1, 2, 5, 10])  # => positive (right-skewed)
+Philiprehberger::MathKit::Stats.kurtosis([2, 3, 4, 5, 6, 7])   # => near 0 (normal-like)
+```
+
+### Confidence Intervals
+
+```ruby
+data = [10, 12, 14, 16, 18]
+lower, upper = Philiprehberger::MathKit::Stats.confidence_interval(data, level: 0.95)
+# => [9.87, 18.13] (approximate)
+```
+
+### Correlation and Covariance
+
+```ruby
+Philiprehberger::MathKit::Stats.correlation([1, 2, 3, 4], [2, 4, 6, 8])  # => 1.0
+Philiprehberger::MathKit::Stats.covariance([1, 2, 3, 4], [2, 4, 6, 8])   # => 3.333...
+```
+
+### Data Normalization
+
+```ruby
+Philiprehberger::MathKit::Stats.normalize([10, 20, 30])       # => [0.0, 0.5, 1.0]
+Philiprehberger::MathKit::Stats.standardize([10, 20, 30, 40]) # => z-scores (mean=0, stddev=1)
+```
+
+### Robust Statistics
+
+```ruby
+Philiprehberger::MathKit::Stats.median_absolute_deviation([1, 1, 2, 2, 4, 6, 9])  # => 1.0
+Philiprehberger::MathKit::Stats.trimmed_mean([1, 2, 3, 4, 100], trim: 0.2)        # => 3.0
+Philiprehberger::MathKit::Stats.winsorized_mean([1, 2, 3, 4, 100], trim: 0.2)     # => less affected by outlier
+```
+
+### Linear Regression
+
+```ruby
+result = Philiprehberger::MathKit::Regression.linear([1, 2, 3, 4], [2, 4, 6, 8])
+result.slope      # => 2.0
+result.intercept  # => 0.0
+result.r_squared  # => 1.0
+result.predict(5) # => 10.0
 ```
 
 ### Interpolation
@@ -67,7 +106,6 @@ Philiprehberger::MathKit::Round.bankers(3.5)                  # => 4.0
 Philiprehberger::MathKit::Round.ceiling(2.1)                  # => 3.0
 Philiprehberger::MathKit::Round.floor(2.9)                    # => 2.0
 Philiprehberger::MathKit::Round.truncate(2.9)                 # => 2.0
-Philiprehberger::MathKit::Round.truncate(-2.9)                # => -2.0
 Philiprehberger::MathKit::Round.bankers(2.55, precision: 1)   # => 2.6
 ```
 
@@ -80,32 +118,87 @@ Philiprehberger::MathKit::MovingAverage.exponential([1, 2, 3, 4, 5], alpha: 0.5)
 
 ## API
 
+### `Stats`
+
 | Method | Description |
 |--------|-------------|
-| `Stats.mean(values)` | Arithmetic mean |
-| `Stats.median(values)` | Median (middle value or average of two middle) |
-| `Stats.mode(values)` | Mode(s) as array |
-| `Stats.variance(values, population: true)` | Population or sample variance |
-| `Stats.stddev(values, population: true)` | Standard deviation |
-| `Stats.percentile(values, p)` | Percentile (0-100) |
-| `Stats.sum(values)` | Sum of values |
-| `Stats.range(values)` | Max - min |
-| `Interpolation.linear(points, x)` | Linear interpolation between points |
-| `Round.bankers(value, precision: 0)` | Banker's rounding (round half to even) |
-| `Round.ceiling(value, precision: 0)` | Round up |
-| `Round.floor(value, precision: 0)` | Round down |
-| `Round.truncate(value, precision: 0)` | Truncate toward zero |
-| `MovingAverage.simple(values, window:)` | Simple moving average |
-| `MovingAverage.exponential(values, alpha:)` | Exponential moving average |
+| `.mean(values)` | Arithmetic mean |
+| `.median(values)` | Median (middle value or average of two middle) |
+| `.mode(values)` | Mode(s) as array |
+| `.variance(values, population: true)` | Population or sample variance |
+| `.stddev(values, population: true)` | Standard deviation |
+| `.percentile(values, p)` | Percentile (0-100) with linear interpolation |
+| `.sum(values)` | Sum of values |
+| `.range(values)` | Max - min |
+| `.skewness(values)` | Sample skewness (Fisher-Pearson) |
+| `.kurtosis(values)` | Sample excess kurtosis (Fisher definition) |
+| `.confidence_interval(values, level: 0.95)` | Confidence interval for the mean |
+| `.correlation(xs, ys)` | Pearson correlation coefficient |
+| `.covariance(xs, ys)` | Sample covariance |
+| `.normalize(values)` | Min-max normalization to 0..1 |
+| `.standardize(values)` | Z-score standardization (mean=0, stddev=1) |
+| `.median_absolute_deviation(values)` | Median absolute deviation |
+| `.trimmed_mean(values, trim: 0.1)` | Trimmed mean (remove fraction from each end) |
+| `.winsorized_mean(values, trim: 0.1)` | Winsorized mean (clamp extremes) |
+
+### `Regression`
+
+| Method | Description |
+|--------|-------------|
+| `.linear(xs, ys)` | Ordinary least squares linear regression |
+| `Result#slope` | Slope of the fitted line |
+| `Result#intercept` | Y-intercept of the fitted line |
+| `Result#r_squared` | Coefficient of determination (0 to 1) |
+| `Result#predict(x)` | Predict y for a given x |
+
+### `Interpolation`
+
+| Method | Description |
+|--------|-------------|
+| `.linear(points, x)` | Linear interpolation between sorted points |
+
+### `Round`
+
+| Method | Description |
+|--------|-------------|
+| `.bankers(value, precision: 0)` | Banker's rounding (round half to even) |
+| `.ceiling(value, precision: 0)` | Round up |
+| `.floor(value, precision: 0)` | Round down |
+| `.truncate(value, precision: 0)` | Truncate toward zero |
+
+### `MovingAverage`
+
+| Method | Description |
+|--------|-------------|
+| `.simple(values, window:)` | Simple moving average |
+| `.exponential(values, alpha:)` | Exponential moving average |
 
 ## Development
 
 ```bash
 bundle install
-bundle exec rspec      # Run tests
-bundle exec rubocop    # Check code style
+bundle exec rspec
+bundle exec rubocop
 ```
 
+## Support
+
+If you find this project useful:
+
+⭐ [Star the repo](https://github.com/philiprehberger/rb-math-kit)
+
+🐛 [Report issues](https://github.com/philiprehberger/rb-math-kit/issues?q=is%3Aissue+is%3Aopen+label%3Abug)
+
+💡 [Suggest features](https://github.com/philiprehberger/rb-math-kit/issues?q=is%3Aissue+is%3Aopen+label%3Aenhancement)
+
+❤️ [Sponsor development](https://github.com/sponsors/philiprehberger)
+
+🌐 [All Open Source Projects](https://philiprehberger.com/open-source-packages)
+
+💻 [GitHub Profile](https://github.com/philiprehberger)
+
+🔗 [LinkedIn Profile](https://www.linkedin.com/in/philiprehberger)
+
 ## License
 
-MIT
+[MIT](LICENSE)

data/lib/philiprehberger/math_kit/regression.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module MathKit
+    # Linear regression analysis
+    module Regression
+      # Result of a linear regression
+      Result = Struct.new(:slope, :intercept, :r_squared, keyword_init: true) do
+        # Predict the y value for a given x
+        #
+        # @param x [Numeric] the input value
+        # @return [Float] the predicted y value
+        def predict(x)
+          intercept + (slope * x)
+        end
+      end
+
+      class << self
+        # Perform ordinary least squares linear regression
+        #
+        # @param xs [Array<Numeric>] independent variable values
+        # @param ys [Array<Numeric>] dependent variable values
+        # @return [Result] regression result with slope, intercept, and r_squared
+        # @raise [ArgumentError] if arrays differ in size or have fewer than 2 points
+        def linear(xs, ys)
+          raise ArgumentError, 'datasets must have the same size' if xs.size != ys.size
+          raise ArgumentError, 'linear regression requires at least 2 data points' if xs.size < 2
+
+          n = xs.size.to_f
+          sum_x = xs.sum.to_f
+          sum_y = ys.sum.to_f
+          sum_xy = xs.zip(ys).sum { |x, y| x * y }.to_f
+          sum_x2 = xs.sum { |x| x**2 }.to_f
+
+          denom = (n * sum_x2) - (sum_x**2)
+          raise ArgumentError, 'all x values are identical — cannot fit a line' if denom.zero?
+
+          slope = ((n * sum_xy) - (sum_x * sum_y)) / denom
+          intercept = (sum_y - (slope * sum_x)) / n
+
+          r_squared = compute_r_squared(ys, xs, slope, intercept)
+
+          Result.new(slope: slope, intercept: intercept, r_squared: r_squared)
+        end
+
+        private
+
+        def compute_r_squared(ys, xs, slope, intercept)
+          mean_y = ys.sum.to_f / ys.size
+          ss_tot = ys.sum { |y| (y - mean_y)**2 }
+          return 1.0 if ss_tot.zero?
+
+          ss_res = xs.zip(ys).sum { |x, y| (y - (intercept + (slope * x)))**2 }
+          1.0 - (ss_res / ss_tot)
+        end
+      end
+    end
+  end
+end

data/lib/philiprehberger/math_kit/stats.rb

@@ -115,6 +115,233 @@ module Philiprehberger
 
           values.max - values.min
         end
+
+        # Sample skewness (Fisher-Pearson)
+        #
+        # @param values [Array<Numeric>] the input values
+        # @return [Float] the sample skewness
+        # @raise [ArgumentError] if fewer than 3 values
+        def skewness(values)
+          n = values.size
+          raise ArgumentError, 'skewness requires at least 3 values' if n < 3
+
+          avg = mean(values)
+          s = stddev(values, population: false)
+          return 0.0 if s.zero?
+
+          m3 = values.sum { |v| (v - avg)**3 } / n.to_f
+          adjustment = (n.to_f * (n - 1)) / (n - 2)
+          (adjustment / n) * (m3 / (s**3)) * n
+        end
+
+        # Sample excess kurtosis (Fisher definition, normal = 0)
+        #
+        # @param values [Array<Numeric>] the input values
+        # @return [Float] the sample excess kurtosis
+        # @raise [ArgumentError] if fewer than 4 values
+        def kurtosis(values)
+          n = values.size
+          raise ArgumentError, 'kurtosis requires at least 4 values' if n < 4
+
+          avg = mean(values)
+          s2 = variance(values, population: false)
+          return 0.0 if s2.zero?
+
+          m4 = values.sum { |v| (v - avg)**4 } / n.to_f
+          raw = m4 / (s2**2)
+          # Adjusted Fisher kurtosis
+          prefactor = (n.to_f * (n + 1)) / ((n - 1) * (n - 2) * (n - 3))
+          correction = (3.0 * ((n - 1)**2)) / ((n - 2) * (n - 3))
+          (prefactor * n * raw) - correction
+        end
+
+        # Confidence interval for the mean using t-distribution critical values
+        #
+        # @param values [Array<Numeric>] the input values
+        # @param level [Float] confidence level (0.90, 0.95, or 0.99)
+        # @return [Array(Float, Float)] lower and upper bounds
+        # @raise [ArgumentError] if fewer than 2 values or unsupported level
+        def confidence_interval(values, level: 0.95)
+          n = values.size
+          raise ArgumentError, 'confidence interval requires at least 2 values' if n < 2
+
+          t_value = t_critical(n - 1, level)
+          avg = mean(values)
+          se = stddev(values, population: false) / Math.sqrt(n)
+          margin = t_value * se
+
+          [avg - margin, avg + margin]
+        end
+
+        # Pearson correlation coefficient between two datasets
+        #
+        # @param xs [Array<Numeric>] first dataset
+        # @param ys [Array<Numeric>] second dataset
+        # @return [Float] the Pearson correlation coefficient (-1 to 1)
+        # @raise [ArgumentError] if datasets differ in size or have fewer than 2 values
+        def correlation(xs, ys)
+          raise ArgumentError, 'datasets must have the same size' if xs.size != ys.size
+          raise ArgumentError, 'correlation requires at least 2 values' if xs.size < 2
+
+          cov = covariance(xs, ys)
+          sx = stddev(xs, population: false)
+          sy = stddev(ys, population: false)
+          return 0.0 if sx.zero? || sy.zero?
+
+          cov / (sx * sy)
+        end
+
+        # Sample covariance between two datasets
+        #
+        # @param xs [Array<Numeric>] first dataset
+        # @param ys [Array<Numeric>] second dataset
+        # @return [Float] the sample covariance
+        # @raise [ArgumentError] if datasets differ in size or have fewer than 2 values
+        def covariance(xs, ys)
+          raise ArgumentError, 'datasets must have the same size' if xs.size != ys.size
+          raise ArgumentError, 'covariance requires at least 2 values' if xs.size < 2
+
+          n = xs.size
+          avg_x = mean(xs)
+          avg_y = mean(ys)
+          xs.zip(ys).sum { |x, y| (x - avg_x) * (y - avg_y) } / (n - 1).to_f
+        end
+
+        # Min-max normalization to 0..1 range
+        #
+        # @param values [Array<Numeric>] the input values
+        # @return [Array<Float>] normalized values
+        # @raise [ArgumentError] if values is empty
+        def normalize(values)
+          raise ArgumentError, 'values must not be empty' if values.empty?
+
+          min_val = values.min.to_f
+          max_val = values.max.to_f
+          span = max_val - min_val
+          return values.map { 0.0 } if span.zero?
+
+          values.map { |v| (v - min_val) / span }
+        end
+
+        # Z-score standardization (mean=0, stddev=1)
+        #
+        # @param values [Array<Numeric>] the input values
+        # @return [Array<Float>] standardized values
+        # @raise [ArgumentError] if fewer than 2 values
+        def standardize(values)
+          raise ArgumentError, 'standardize requires at least 2 values' if values.size < 2
+
+          avg = mean(values)
+          s = stddev(values, population: false)
+          return values.map { 0.0 } if s.zero?
+
+          values.map { |v| (v - avg) / s }
+        end
+
+        # Median absolute deviation
+        #
+        # @param values [Array<Numeric>] the input values
+        # @return [Float] the MAD
+        # @raise [ArgumentError] if values is empty
+        def median_absolute_deviation(values)
+          raise ArgumentError, 'values must not be empty' if values.empty?
+
+          med = median(values)
+          deviations = values.map { |v| (v - med).abs }
+          median(deviations)
+        end
+
+        # Trimmed mean (removes a fraction from each end before averaging)
+        #
+        # @param values [Array<Numeric>] the input values
+        # @param trim [Float] fraction to trim from each end (0.0 to 0.5 exclusive)
+        # @return [Float] the trimmed mean
+        # @raise [ArgumentError] if values is empty or trim is out of range
+        def trimmed_mean(values, trim: 0.1)
+          raise ArgumentError, 'values must not be empty' if values.empty?
+          raise ArgumentError, 'trim must be between 0.0 and 0.5 (exclusive)' if trim.negative? || trim >= 0.5
+
+          sorted = values.sort
+          n = sorted.size
+          k = (n * trim).floor
+          return mean(sorted) if k.zero?
+
+          trimmed = sorted[k..-(k + 1)]
+          mean(trimmed)
+        end
+
+        # Winsorized mean (replaces extremes with boundary values before averaging)
+        #
+        # @param values [Array<Numeric>] the input values
+        # @param trim [Float] fraction to winsorize from each end (0.0 to 0.5 exclusive)
+        # @return [Float] the winsorized mean
+        # @raise [ArgumentError] if values is empty or trim is out of range
+        def winsorized_mean(values, trim: 0.1)
+          raise ArgumentError, 'values must not be empty' if values.empty?
+          raise ArgumentError, 'trim must be between 0.0 and 0.5 (exclusive)' if trim.negative? || trim >= 0.5
+
+          sorted = values.sort
+          n = sorted.size
+          k = (n * trim).floor
+          return mean(sorted) if k.zero?
+
+          low = sorted[k]
+          high = sorted[-(k + 1)]
+          winsorized = sorted.map { |v| [[v, low].max, high].min }
+          mean(winsorized)
+        end
+
+        private
+
+        # T-distribution critical values for common confidence levels
+        # Uses a lookup table for degrees of freedom up to 200 and common levels
+        #
+        # @param df [Integer] degrees of freedom
+        # @param level [Float] confidence level
+        # @return [Float] the t critical value
+        def t_critical(df, level)
+          # Two-tailed critical values for common levels
+          # For large df (>120), use z-approximation
+          t_values = {
+            0.90 => { 1 => 6.314, 2 => 2.920, 3 => 2.353, 4 => 2.132, 5 => 2.015,
+                      6 => 1.943, 7 => 1.895, 8 => 1.860, 9 => 1.833, 10 => 1.812,
+                      15 => 1.753, 20 => 1.725, 25 => 1.708, 30 => 1.697,
+                      40 => 1.684, 50 => 1.676, 60 => 1.671, 80 => 1.664,
+                      100 => 1.660, 120 => 1.658 },
+            0.95 => { 1 => 12.706, 2 => 4.303, 3 => 3.182, 4 => 2.776, 5 => 2.571,
+                      6 => 2.447, 7 => 2.365, 8 => 2.306, 9 => 2.262, 10 => 2.228,
+                      15 => 2.131, 20 => 2.086, 25 => 2.060, 30 => 2.042,
+                      40 => 2.021, 50 => 2.009, 60 => 2.000, 80 => 1.990,
+                      100 => 1.984, 120 => 1.980 },
+            0.99 => { 1 => 63.657, 2 => 9.925, 3 => 5.841, 4 => 4.604, 5 => 4.032,
+                      6 => 3.707, 7 => 3.499, 8 => 3.355, 9 => 3.250, 10 => 3.169,
+                      15 => 2.947, 20 => 2.845, 25 => 2.787, 30 => 2.750,
+                      40 => 2.704, 50 => 2.678, 60 => 2.660, 80 => 2.639,
+                      100 => 2.626, 120 => 2.617 }
+          }
+
+          z_values = { 0.90 => 1.645, 0.95 => 1.960, 0.99 => 2.576 }
+
+          raise ArgumentError, "unsupported confidence level: #{level}. Use 0.90, 0.95, or 0.99" unless t_values.key?(level)
+
+          return z_values[level] if df > 120
+
+          table = t_values[level]
+          return table[df] if table.key?(df)
+
+          # Interpolate between nearest known degrees of freedom
+          keys = table.keys.sort
+          lower = keys.select { |k| k <= df }.last
+          upper = keys.select { |k| k >= df }.first
+
+          return table[lower] if lower == upper
+
+          # Linear interpolation
+          t_low = table[lower]
+          t_high = table[upper]
+          fraction = (df - lower).to_f / (upper - lower)
+          t_low + (fraction * (t_high - t_low))
+        end
       end
     end
   end

data/lib/philiprehberger/math_kit/version.rb

@@ -2,6 +2,6 @@
 
 module Philiprehberger
   module MathKit
-    VERSION = '0.1.0'
+    VERSION = '0.2.1'
   end
 end

data/lib/philiprehberger/math_kit.rb

@@ -5,6 +5,7 @@ require_relative 'math_kit/stats'
 require_relative 'math_kit/interpolation'
 require_relative 'math_kit/round'
 require_relative 'math_kit/moving_average'
+require_relative 'math_kit/regression'
 
 module Philiprehberger
   module MathKit

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: philiprehberger-math_kit
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Philip Rehberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-27 00:00:00.000000000 Z
+date: 2026-03-31 00:00:00.000000000 Z
 dependencies: []
 description: Descriptive statistics, linear interpolation, rounding modes, and moving
   averages. Lightweight math toolkit with zero dependencies.
@@ -24,6 +24,7 @@ files:
 - lib/philiprehberger/math_kit.rb
 - lib/philiprehberger/math_kit/interpolation.rb
 - lib/philiprehberger/math_kit/moving_average.rb
+- lib/philiprehberger/math_kit/regression.rb
 - lib/philiprehberger/math_kit/round.rb
 - lib/philiprehberger/math_kit/stats.rb
 - lib/philiprehberger/math_kit/version.rb
@@ -54,5 +55,5 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Common math and statistics utilities for Ruby
+summary: Statistics, interpolation, rounding modes, and moving averages for Ruby
 test_files: []