savanna-outliers 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YjhlN2E2NjM5Zjg4NTM4ODUzM2NkM2E1ZmQyNmQ0ZTgyM2YyZDhhOQ==
+  data.tar.gz: !binary |-
+    NWY1NjY2MjFiNDM2M2U4OTk4YTZmNTAyZjI3ZjYxNDc0MzU2YWZhMA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YjMzMjJiNTUzYzBmMGUyODJlODI5ZmJmMzQwNWM1OGViYmE3MmI2YjZjMjQx
+    MjE2YTNmOWFjMWUzZDAzZjM2YjI0NTFkNzcwNDczZWY1ODMwMDY4OGY5N2Q4
+    ODZmMWIyZTU2MDY5YjQ5OGYyOWVkNGVmY2RjNjNiNTZkYzY1ZGE=
+  data.tar.gz: !binary |-
+    Mjg5OWQzMDY2NTU2ZDI3OTYzNmIxMDAxNDUyYmUwNGE3ZTA1MDQwNzBiYjY0
+    ZTg2YTRmNDc3MjNkZTU5OTJlYTgxYjFhZjg0OGM4MTliZWQyNDQxYTlkOWI4
+    ZDlhNGE3NzE1ZDllM2M0YjMzMTM2MDI3YWUyNjRjZGQzZTVlYWE=

data/lib/savanna-outliers.rb

@@ -0,0 +1 @@
+require 'savanna-outliers/savanna_outliers'

data/lib/savanna-outliers/chauvenets.rb

@@ -0,0 +1,27 @@
+module Savanna
+  module Outliers
+    module Chauvenets
+      def chauvenets_criterion_min
+        delta = (mean - array.min).abs
+        (1/standard_deviation)*Statistics2.normaldist((delta - mean)/standard_deviation)*size
+      end
+
+      def chauvenets_criterion_max
+        delta = (mean - array.max).abs
+        (1/standard_deviation)*Statistics2.normaldist((delta - mean)/standard_deviation)*size
+      end
+
+      def outliers_chauvenets?
+        @outliers_chauvenets ||= max_outlier_chauvenets? or min_outlier_chauvenets?
+      end
+
+      def max_outlier_chauvenets?
+        @max_outliers_chauvenets ||= chauvenets_criterion_max < 0.5
+      end
+
+      def min_outlier_chauvenets?
+        @min_outliers_chauvenets ||= chauvenets_criterion_min < 0.5
+      end
+    end
+  end
+end

data/lib/savanna-outliers/core.rb

@@ -0,0 +1,50 @@
+require 'descriptive_statistics/safe'
+require 'statistics2'
+require 'savanna-outliers/general_parameters'
+require 'savanna-outliers/grubbs'
+require 'savanna-outliers/chauvenets'
+require 'savanna-outliers/operations'
+
+module Savanna
+  module Outliers
+    class Core
+      include Savanna::Outliers::GeneralParameters
+      include Savanna::Outliers::Grubbs
+      include Savanna::Outliers::Chauvenets
+      include Savanna::Outliers::Operations
+      attr_reader :array
+      attr_accessor :method
+      def initialize(input_array, method = :grubbs)
+        @array = input_array.extend(DescriptiveStatistics)
+        @method = method
+      end
+
+      def outliers?
+        case
+          when method == :grubbs then outliers_grubbs?
+          when method == :chauvenets then outliers_chauvenets?
+        end
+      end
+
+      def max_outlier?
+        case
+          when method == :grubbs then max_outlier_grubbs?
+          when method == :chauvenets then max_outlier_chauvenets?
+        end
+      end
+
+      def min_outlier?
+        case
+          when method == :grubbs then min_outlier_grubbs?
+          when method == :chauvenets then min_outlier_chauvenets?
+        end
+      end
+
+      private
+
+      def indexed_array
+        @indexed_array ||= array.each_with_index
+      end
+    end
+  end
+end

data/lib/savanna-outliers/general_parameters.rb

@@ -0,0 +1,25 @@
+module Savanna
+  module Outliers
+    module GeneralParameters
+      def size
+        @size ||= array.size
+      end
+
+      def mean
+        @mean ||= array.mean
+      end
+
+      def set_mean(m)
+        @mean = m
+      end
+
+      def set_standard_deviation(sd)
+        @standard_deviation = sd
+      end
+
+      def standard_deviation
+        @standard_deviation ||= array.standard_deviation
+      end
+    end
+  end
+end

data/lib/savanna-outliers/grubbs.rb

@@ -0,0 +1,43 @@
+module Savanna
+  module Outliers
+    module Grubbs
+      def grubbs_test_statistic
+        array.map{|el| (el - mean).abs}.max/standard_deviation
+      end
+
+      def grubbs_test_statistic_maximum
+        (array.max - mean)/standard_deviation
+      end
+
+      def grubbs_test_statistic_minimum
+        (mean - array.min)/standard_deviation
+      end
+
+      def grubbs_two_sided_test(n = size, alpha = 0.05)
+        a = (n - 1)/Math.sqrt(n)
+        t = Statistics2.ptdist(n-2,alpha/(2*n))**2
+        b = Math.sqrt( t/(n-2+t) )
+        a*b
+      end
+
+      def grubbs_one_sided_test(n = size, alpha = 0.05)
+        a = (n - 1)/Math.sqrt(n)
+        t = Statistics2.ptdist(n-2,alpha/n)**2
+        b = Math.sqrt( t/(n-2+t) )
+        a*b
+      end
+
+      def outliers_grubbs?
+        @outliers_grubbs ||= grubbs_test_statistic > grubbs_two_sided_test
+      end
+
+      def max_outlier_grubbs?
+        @max_outliers_grubbs ||= grubbs_test_statistic_maximum > grubbs_one_sided_test
+      end
+
+      def min_outlier_grubbs?
+        @min_outliers_grubbs ||= grubbs_test_statistic_minimum > grubbs_one_sided_test
+      end
+    end
+  end
+end

data/lib/savanna-outliers/operations.rb

@@ -0,0 +1,21 @@
+module Savanna
+  module Outliers
+    module Operations
+      def get_max_outlier
+        indexed_array.max[0] if max_outlier?
+      end
+
+      def get_min_outlier
+        indexed_array.min[0] if min_outlier?
+      end
+
+      def get_max_outlier_index
+        indexed_array.max[1] if max_outlier?
+      end
+
+      def get_min_outlier_index
+        indexed_array.min[1] if min_outlier?
+      end
+    end
+  end
+end

data/lib/savanna-outliers/savanna_outliers.rb

@@ -0,0 +1,132 @@
+require 'savanna-outliers/core'
+
+module Savanna
+  module Outliers
+    self.extend Savanna::Outliers
+    def outliers?(dataset, type = :all, method = :grubbs)
+      case
+        when (dataset.class == Array && type == :all) then Core.new(dataset, method).outliers?
+        when (dataset.class == Array && type == :max) then Core.new(dataset, method).max_outlier?
+        when (dataset.class == Array && type == :min) then Core.new(dataset, method).min_outlier?
+        when (dataset.class == Hash  && type == :all) then Core.new(dataset.values, method).outliers?
+        when (dataset.class == Hash  && type == :max) then Core.new(dataset.values, method).max_outlier?
+        when (dataset.class == Hash  && type == :min) then Core.new(dataset.values, method).min_outlier?
+      end
+    end
+
+    def get_outliers(dataset, type = :all, method = :grubbs)
+      case
+        when (dataset.class == Array && type == :all) then get_all_outliers_from_array(dataset, method)
+        when (dataset.class == Array && type == :max) then get_max_outliers_from_array(dataset, method)
+        when (dataset.class == Array && type == :min) then get_min_outliers_from_array(dataset, method)
+        when (dataset.class == Hash  && type == :all) then get_all_outliers_from_hash(dataset, method)
+        when (dataset.class == Hash  && type == :max) then get_max_outliers_from_hash(dataset, method)
+        when (dataset.class == Hash  && type == :min) then get_min_outliers_from_hash(dataset, method)
+      end
+    end
+
+    def remove_outliers(dataset, type = :all, method = :grubbs)
+      case
+        when (dataset.class == Array && type == :all) then remove_all_outliers_from_array(dataset, method)
+        when (dataset.class == Array && type == :max) then remove_max_outliers_from_array(dataset, method)
+        when (dataset.class == Array && type == :min) then remove_min_outliers_from_array(dataset, method)
+        when (dataset.class == Hash  && type == :all) then remove_all_outliers_from_hash(dataset, method)
+        when (dataset.class == Hash  && type == :max) then remove_max_outliers_from_hash(dataset, method)
+        when (dataset.class == Hash  && type == :min) then remove_min_outliers_from_hash(dataset, method)
+      end
+    end
+
+    private
+
+    def get_max_outliers_from_array(array, method)
+      input_array = array.clone; outliers = []
+      outliers << input_array.delete_at(Core.new(input_array, method).get_max_outlier_index) while Core.new(input_array, method).max_outlier?
+      outliers
+    end
+
+    def get_min_outliers_from_array(array, method)
+      input_array = array.clone; outliers = []
+      outliers << input_array.delete_at(Core.new(input_array, method).get_min_outlier_index) while Core.new(input_array, method).min_outlier?
+      outliers
+    end
+
+    def get_all_outliers_from_array(array, method)
+      get_max_outliers_from_array(array, method) + get_min_outliers_from_array(array, method)
+    end
+
+    def get_max_outliers_from_hash(hash, method)
+      keys_array = hash.keys; input_array = hash.values
+      output_keys = []; output_values = []
+      while Core.new(input_array, method).max_outlier?
+        index = Core.new(input_array, method).get_max_outlier_index
+        output_values << input_array.delete_at(index)
+        output_keys << keys_array.delete_at(index)
+      end
+      build_hash(output_keys, output_values)
+    end
+
+    def get_min_outliers_from_hash(hash, method)
+      keys_array = hash.keys; input_array = hash.values
+      output_keys = []; output_values = []
+      while Core.new(input_array, method).min_outlier?
+        index = Core.new(input_array, method).get_min_outlier_index
+        output_values << input_array.delete_at(index)
+        output_keys << keys_array.delete_at(index)
+      end
+      build_hash(output_keys, output_values)
+    end
+
+    def get_all_outliers_from_hash(hash, method)
+      get_max_outliers_from_hash(hash, method).merge(get_min_outliers_from_hash(hash, method))
+    end
+
+    def remove_max_outliers_from_array(array, method)
+      input_array = array.clone
+      input_array.delete_at(Core.new(input_array, method).get_max_outlier_index) while Core.new(input_array, method).max_outlier?
+      input_array
+    end
+
+    def remove_min_outliers_from_array(array, method)
+      input_array = array.clone
+      input_array.delete_at(Core.new(input_array, method).get_min_outlier_index) while Core.new(input_array, method).min_outlier?
+      input_array
+    end
+
+    def remove_all_outliers_from_array(array, method)
+      array - get_all_outliers_from_array(array, method)
+    end
+
+    def remove_max_outliers_from_hash(hash, method)
+      keys_array = hash.keys; input_array = hash.values
+      while Core.new(input_array, method).max_outlier?
+        index = Core.new(input_array, method).get_max_outlier_index
+        input_array.delete_at(index)
+        keys_array.delete_at(index)
+      end
+      build_hash(keys_array, input_array)
+    end
+
+    def remove_min_outliers_from_hash(hash, method)
+      keys_array = hash.keys; input_array = hash.values
+      while Core.new(input_array, method).min_outlier?
+        index = Core.new(input_array, method).get_min_outlier_index
+        input_array.delete_at(index)
+        keys_array.delete_at(index)
+      end
+      build_hash(keys_array, input_array)
+    end
+
+    def remove_all_outliers_from_hash(hash, method)
+      get_all_outliers_from_hash(hash, method).keys.each do |key|
+        hash.tap { |hs| hs.delete(key) }
+      end
+      hash
+    end
+
+    def build_hash(keys, values)
+      output_hash = {}
+      keys.each_index{|i| output_hash[keys[i]] = values[i]}
+      output_hash
+    end
+  end
+end

data/lib/savanna-outliers/version.rb

@@ -0,0 +1,5 @@
+module Savanna
+  module Outliers
+  	VERSION = '0.0.1'
+  end
+end

data/spec/savanna-outliers/core_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe 'Savanna Outliers Core' do
+  before(:each) do
+    @simple_example = Savanna::Outliers::Core.new([1,2,3,4,5,100,200,300])
+    @min_outlier_example = Savanna::Outliers::Core.new([-30,20,25,19,21,22,23,18])
+    @max_outlier_example = Savanna::Outliers::Core.new([100,20,25,19,21,22,23,18])
+    @min_max_outlier_example = Savanna::Outliers::Core.new([100,20,25,19,21,22,23,18,1])
+  end
+
+  it 'should return array' do
+    @simple_example.array.should == [1,2,3,4,5,100,200,300]
+  end
+
+  it 'should return size' do
+    @simple_example.size.should == 8
+  end
+
+  it 'should return mean' do
+    @simple_example.mean.should == 76.875
+  end
+
+  it 'should return standard deviation' do
+    @simple_example.standard_deviation.should == 107.68987591691246
+  end
+
+  it 'should calculate grubbs test statistic' do
+    @simple_example.grubbs_test_statistic.should == 2.0719217855924628
+  end
+
+  it 'should calculate grubbs test statistic for maximum' do
+    @simple_example.grubbs_test_statistic_maximum.should == 2.0719217855924628
+  end
+
+  it 'should calculate grubbs test statistic for minimum' do
+    @simple_example.grubbs_test_statistic_minimum.should == 0.7045694811510503
+  end
+
+  it 'should calculate grubbs two sided test' do
+    @simple_example.grubbs_two_sided_test(3,0.05).should == 1.1543048503229865
+    @simple_example.grubbs_two_sided_test(10).should == 2.289952254608721
+  end
+
+  it 'should calculate grubbs one sided test' do
+    @simple_example.grubbs_one_sided_test(3,0.05).should == 1.1531180570049688
+    @simple_example.grubbs_one_sided_test(10).should == 2.176061415982935
+  end
+
+  it 'should identify outliers existance with grubbs' do
+    @min_max_outlier_example.outliers_grubbs?.should == true
+    @min_max_outlier_example.method = :grubbs
+    @min_max_outlier_example.outliers?.should == true
+  end
+
+  it 'should identify min outlier existance with grubbs' do
+    @min_outlier_example.min_outlier_grubbs?.should == true
+    @min_outlier_example.method = :grubbs
+    @min_outlier_example.min_outlier?.should == true
+  end
+
+  it 'should identify max outlier existance with grubbs' do
+    @max_outlier_example.max_outlier_grubbs?.should == true
+    @max_outlier_example.method = :grubbs
+    @max_outlier_example.max_outlier?.should == true
+  end
+
+  it 'should identify outliers existance with chauvenets' do
+    @min_max_outlier_example.outliers_chauvenets?.should == true
+    @min_max_outlier_example.method = :chauvenets
+    @min_max_outlier_example.outliers?.should == true
+  end
+
+  it 'should identify min outlier existance with chauvenets' do
+    @min_outlier_example.min_outlier_chauvenets?.should == true
+    @min_outlier_example.method = :chauvenets
+    @min_outlier_example.min_outlier?.should == true
+  end
+
+  it 'should identify max outlier existance with chauvenets' do
+    @max_outlier_example.max_outlier_chauvenets?.should == true
+    @max_outlier_example.method = :chauvenets
+    @max_outlier_example.max_outlier?.should == true
+  end
+
+  it 'should return max outlier' do
+    @max_outlier_example.get_max_outlier.should == 100
+  end
+
+  it 'should return min outlier' do
+    @min_outlier_example.get_min_outlier.should == -30
+  end
+
+  it 'should return max outlier index' do
+    @max_outlier_example.get_max_outlier_index.should == 0
+  end
+
+  it 'should return min outlier index' do
+    @min_outlier_example.get_min_outlier_index.should == 0
+  end
+end

data/spec/savanna-outliers/outliers_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe 'Savanna Outliers' do
+
+  it 'should identify any outliers existance' do
+    array_one = [10, 12, 8, 11, 9, 13, 12, 10, 1000, 12, 10, 1100, 9, 5000]
+    hash_one = {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, i: 1000, j: 12, k: 10, l: 1100, m: 9, n: 5000}
+    Savanna::Outliers.outliers?(array_one, :all, :grubbs).should == true
+    Savanna::Outliers.outliers?(hash_one, :all, :grubbs).should == true
+  end
+
+  it 'should identify max outliers existance' do
+    array_one = [10, 12, 8, 11, 9, 13, 12, 10, 1000, 12, 10, 1100, 9, 5000]
+    hash_one = {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, i: 1000, j: 12, k: 10, l: 1100, m: 9, n: 5000}
+    Savanna::Outliers.outliers?(array_one, :max, :grubbs).should == true
+    Savanna::Outliers.outliers?(hash_one, :max, :grubbs).should == true
+    Savanna::Outliers.outliers?(array_one, :max).should == true
+    Savanna::Outliers.outliers?(hash_one, :max).should == true
+  end
+
+  it 'should identify min outliers existance' do
+    array_one = [10, 12, 8, 11, 9, 13, 12, 10, -1000, 12, 10, -1100, 9, -5000]
+    hash_one = {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, i: -1000, j: 12, k: 10, l: -1100, m: 9, n: -5000}
+    Savanna::Outliers.outliers?(array_one, :min, :grubbs).should == true
+    Savanna::Outliers.outliers?(hash_one, :min, :grubbs).should == true
+    Savanna::Outliers.outliers?(array_one, :min).should == true
+    Savanna::Outliers.outliers?(hash_one, :min).should == true
+  end
+
+  it 'should return max outliers from array' do
+    array_one = [10, 12, 8, 11, 9, 13, 12, 10, 1000, 12, 10, 1100, 9, 5000]
+    array_two = [20, 30, 100, 10, 15, 10, 12, 13, 5, 25, 40, 35, 22, 15, 90]
+    Savanna::Outliers.get_outliers(array_one, :max, :grubbs).should == [5000, 1100, 1000]
+    Savanna::Outliers.get_outliers(array_two, :max, :grubbs).should == [100, 90]
+    Savanna::Outliers.get_outliers(array_one, :max).should == [5000, 1100, 1000]
+    Savanna::Outliers.get_outliers(array_two, :max).should == [100, 90]
+  end
+
+  it 'should return min outliers from array' do
+    array_one = [10, 12, 8, 11, 9, 13, 12, 10, -1000, 12, 10, -1100, 9, -5000]
+    array_two = [20, 30, -100, 10, 15, 10, 12, 13, 5, 25, 40, 35, 22, 15, -90]
+    Savanna::Outliers.get_outliers(array_one, :min, :grubbs).should == [-5000, -1100, -1000]
+    Savanna::Outliers.get_outliers(array_two, :min, :grubbs).should == [-100, -90]
+    Savanna::Outliers.get_outliers(array_one, :min).should == [-5000, -1100, -1000]
+    Savanna::Outliers.get_outliers(array_two, :min).should == [-100, -90]
+  end
+
+  it 'should return all outliers from array' do
+    array_one = [10, 12, 8, 11, 9, 13, 12, 10, -1000, 1000, 12, 10, 9]
+    array_two = [20, 30, -100, 140, 10, 15, 10, 12, 13, 5, 25, 40, 35, 22, 15]
+    Savanna::Outliers.get_outliers(array_one, :all, :grubbs).should == [1000, -1000]
+    Savanna::Outliers.get_outliers(array_two, :all, :grubbs).should == [140, -100]
+    Savanna::Outliers.get_outliers(array_one, :all).should == [1000, -1000]
+    Savanna::Outliers.get_outliers(array_two, :all).should == [140, -100]
+  end
+
+
+  it 'should return max outliers from hash' do
+    hash_one = {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, i: 1000, j: 12, k: 10, l: 1100, m: 9, n: 5000}
+    hash_two = {a: 20, b: 30, c: 100, d: 10, e: 15, f: 10, g: 12, h: 13, i: 5, j: 25, k: 40, l: 35, m: 22, n: 15, o: 90}
+    Savanna::Outliers.get_outliers(hash_one, :max, :grubbs).should == {n: 5000, l: 1100, i: 1000}
+    Savanna::Outliers.get_outliers(hash_two, :max, :grubbs).should == {c: 100, o: 90}
+    Savanna::Outliers.get_outliers(hash_one, :max).should == {n: 5000, l: 1100, i: 1000}
+    Savanna::Outliers.get_outliers(hash_two, :max).should == {c: 100, o: 90}
+  end
+
+  it 'should return min outliers from hash' do
+    hash_one = {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, i: -1000, j: 12, k: 10, l: -1100, m: 9, n: -5000}
+    hash_two = {a: 20, b: 30, c: -100, d: 10, e: 15, f: 10, g: 12, h: 13, i: 5, j: 25, k: 40, l: 35, m: 22, n: 15, o: -90}
+    Savanna::Outliers.get_outliers(hash_one, :min, :grubbs).should == {n: -5000, l: -1100, i: -1000}
+    Savanna::Outliers.get_outliers(hash_two, :min, :grubbs).should == {c: -100, o: -90}
+    Savanna::Outliers.get_outliers(hash_one, :min).should == {n: -5000, l: -1100, i: -1000}
+    Savanna::Outliers.get_outliers(hash_two, :min).should == {c: -100, o: -90}
+  end
+
+  it 'should return all outliers from hash' do
+    hash_one = {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, i: -1000, j: 1000, k: 12, l: 10, m: 9}
+    hash_two = {a: 20, b: 30, c: -100, d: 140, e: 10, f: 15, g: 10, h: 12, i: 13, j: 5, k: 25, l: 40, m: 35, n: 22, o: 15}
+    Savanna::Outliers.get_outliers(hash_one, :all, :grubbs).should == {j: 1000, i: -1000}
+    Savanna::Outliers.get_outliers(hash_two, :all, :grubbs).should == {d: 140, c: -100}
+    Savanna::Outliers.get_outliers(hash_one, :all).should == {j: 1000, i: -1000}
+    Savanna::Outliers.get_outliers(hash_two, :all).should == {d: 140, c: -100}
+  end
+
+###############################
+
+  it 'should remove max outliers from array' do
+    array_one = [10, 12, 8, 11, 9, 13, 12, 10, 1000, 12, 10, 1100, 9, 5000]
+    array_two = [20, 30, 100, 10, 15, 10, 12, 13, 5, 25, 40, 35, 22, 15, 90]
+    Savanna::Outliers.remove_outliers(array_one, :max, :grubbs).should == [10, 12, 8, 11, 9, 13, 12, 10, 12, 10, 9]
+    Savanna::Outliers.remove_outliers(array_two, :max, :grubbs).should == [20, 30, 10, 15, 10, 12, 13, 5, 25, 40, 35, 22, 15]
+    Savanna::Outliers.remove_outliers(array_one, :max).should == [10, 12, 8, 11, 9, 13, 12, 10, 12, 10, 9]
+    Savanna::Outliers.remove_outliers(array_two, :max).should == [20, 30, 10, 15, 10, 12, 13, 5, 25, 40, 35, 22, 15]
+  end
+
+  it 'should remove min outliers from array' do
+    array_one = [10, 12, 8, 11, 9, 13, 12, 10, -1000, 12, 10, -1100, 9, -5000]
+    array_two = [20, 30, -100, 10, 15, 10, 12, 13, 5, 25, 40, 35, 22, 15, -90]
+    Savanna::Outliers.remove_outliers(array_one, :min, :grubbs).should == [10, 12, 8, 11, 9, 13, 12, 10, 12, 10, 9]
+    Savanna::Outliers.remove_outliers(array_two, :min, :grubbs).should == [20, 30, 10, 15, 10, 12, 13, 5, 25, 40, 35, 22, 15]
+    Savanna::Outliers.remove_outliers(array_one, :min).should == [10, 12, 8, 11, 9, 13, 12, 10, 12, 10, 9]
+    Savanna::Outliers.remove_outliers(array_two, :min).should == [20, 30, 10, 15, 10, 12, 13, 5, 25, 40, 35, 22, 15]
+  end
+
+  it 'should remove all outliers from array' do
+    array_one = [10, 12, 8, 11, 9, 13, 12, 10, -1000, 1000, 12, 10, 9]
+    array_two = [20, 30, -100, 140, 10, 15, 10, 12, 13, 5, 25, 40, 35, 22, 15]
+    Savanna::Outliers.remove_outliers(array_one, :all, :grubbs).should == [10, 12, 8, 11, 9, 13, 12, 10, 12, 10, 9]
+    Savanna::Outliers.remove_outliers(array_two, :all, :grubbs).should == [20, 30, 10, 15, 10, 12, 13, 5, 25, 40, 35, 22, 15]
+    Savanna::Outliers.remove_outliers(array_one, :all).should == [10, 12, 8, 11, 9, 13, 12, 10, 12, 10, 9]
+    Savanna::Outliers.remove_outliers(array_two, :all).should == [20, 30, 10, 15, 10, 12, 13, 5, 25, 40, 35, 22, 15]
+  end
+
+
+  it 'should remove max outliers from hash' do
+    hash_one = {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, i: 1000, j: 12, k: 10, l: 1100, m: 9, n: 5000}
+    hash_two = {a: 20, b: 30, c: 100, d: 10, e: 15, f: 10, g: 12, h: 13, i: 5, j: 25, k: 40, l: 35, m: 22, n: 15, o: 90}
+    Savanna::Outliers.remove_outliers(hash_one, :max, :grubbs).should == {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, j: 12, k: 10, m: 9}
+    Savanna::Outliers.remove_outliers(hash_two, :max, :grubbs).should == {a: 20, b: 30, d: 10, e: 15, f: 10, g: 12, h: 13, i: 5, j: 25, k: 40, l: 35, m: 22, n: 15}
+    Savanna::Outliers.remove_outliers(hash_one, :max).should == {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, j: 12, k: 10, m: 9}
+    Savanna::Outliers.remove_outliers(hash_two, :max).should == {a: 20, b: 30, d: 10, e: 15, f: 10, g: 12, h: 13, i: 5, j: 25, k: 40, l: 35, m: 22, n: 15}
+  end
+
+  it 'should remove min outliers from hash' do
+    hash_one = {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, i: -1000, j: 12, k: 10, l: -1100, m: 9, n: -5000}
+    hash_two = {a: 20, b: 30, c: -100, d: 10, e: 15, f: 10, g: 12, h: 13, i: 5, j: 25, k: 40, l: 35, m: 22, n: 15, o: -90}
+    Savanna::Outliers.remove_outliers(hash_one, :min, :grubbs).should == {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, j: 12, k: 10, m: 9}
+    Savanna::Outliers.remove_outliers(hash_two, :min, :grubbs).should == {a: 20, b: 30, d: 10, e: 15, f: 10, g: 12, h: 13, i: 5, j: 25, k: 40, l: 35, m: 22, n: 15}
+    Savanna::Outliers.remove_outliers(hash_one, :min).should == {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, j: 12, k: 10, m: 9}
+    Savanna::Outliers.remove_outliers(hash_two, :min).should == {a: 20, b: 30, d: 10, e: 15, f: 10, g: 12, h: 13, i: 5, j: 25, k: 40, l: 35, m: 22, n: 15}
+  end
+
+  it 'should remove all outliers from hash' do
+    hash_one = {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, i: -1000, j: 1000, k: 12, l: 10, m: 9}
+    hash_two = {a: 20, b: 30, c: -100, d: 140, e: 10, f: 15, g: 10, h: 12, i: 13, j: 5, k: 25, l: 40, m: 35, n: 22, o: 15}
+    Savanna::Outliers.remove_outliers(hash_one, :all, :grubbs).should == {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, k: 12, l: 10, m: 9}
+    Savanna::Outliers.remove_outliers(hash_two, :all, :grubbs).should == {a: 20, b: 30, e: 10, f: 15, g: 10, h: 12, i: 13, j: 5, k: 25, l: 40, m: 35, n: 22, o: 15}
+    Savanna::Outliers.remove_outliers(hash_one, :all).should == {a: 10, b: 12, c: 8, d: 11, e: 9, f: 13, g: 12, h: 10, k: 12, l: 10, m: 9}
+    Savanna::Outliers.remove_outliers(hash_two, :all).should == {a: 20, b: 30, e: 10, f: 15, g: 10, h: 12, i: 13, j: 5, k: 25, l: 40, m: 35, n: 22, o: 15}
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$: << File.join(File.dirname(__FILE__), '/../lib' )
+require 'rspec'
+require 'savanna-outliers'

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: savanna-outliers
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Max Makarochkin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: descriptive_statistics
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: statistics2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Read more documentation at repository homepage.
+email: maxim.makarochkin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/savanna-outliers/chauvenets.rb
+- lib/savanna-outliers/core.rb
+- lib/savanna-outliers/general_parameters.rb
+- lib/savanna-outliers/grubbs.rb
+- lib/savanna-outliers/operations.rb
+- lib/savanna-outliers/savanna_outliers.rb
+- lib/savanna-outliers/version.rb
+- lib/savanna-outliers.rb
+- spec/savanna-outliers/core_spec.rb
+- spec/savanna-outliers/outliers_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/savanna-initiative/savanna-outliers
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: ! 'Savanna outliers: Plug & Play Anomaly Detection'
+test_files: []
+has_rdoc: