average 3.0 → 3.1

data/README.md

@@ -1,6 +1,8 @@
+[![Build Status](https://semaphoreci.com/api/v1/projects/fd96a25e-c843-44ff-8c43-1da486ca03a6/425376/badge.svg)](https://semaphoreci.com/fegoa89/average)      
+
 # Average
 
-TODO: Write a gem description
+Simple gem to calculate mean, median and mode from an array.
 
 ## Installation
 
@@ -18,7 +20,35 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Get Median
+
+    $ [3, 4, 5, 2, 3, 1].mean
+    $ 3.0
+
+Get Mode
+
+    $ [2,4,6,14,21,24,229,24,24,39].mode
+    $ 24
+
+It gives back an array due that could be possible to have more than one mode in a array
+
+    $ [1, 2, 2, 2, 3, 3, 7, 7, 7, 9].mode
+    $ [2, 7]
+
+But if you want to have only a unique mode, you can use 'unique_mode' method (Only for Ruby versions bigger than 1.8.7 -> http://apidock.com/ruby/v1_8_7_72/Enumerable/max_by).
+
+    $ [1, 2, 2, 2, 3, 3, 7, 7, 7, 9].unique_mode
+    $ 2
+
+Get Median
+
+    $ [3,4,5].median
+    $ 4
+    
+All methods described aboved can handle an array of integers, floats, strings or a mixed array with all of them
+    
+    $ [3, "4", 5, 2.0, 3, "1.0"].mean
+    $ 3.0
 
 ## Contributing
 

data/lib/average.rb

@@ -5,6 +5,5 @@ require "average/mode"
 require "average/average_helper"
 require "average/array_overrides"
 
-module Average
-
+class Average
 end

data/lib/average/array_overrides.rb

@@ -1,5 +1,8 @@
-require 'average/mean'
-require 'average/median'
+include Mean
+include Mode
+include Median
+include AverageHelper
+
 class Array
   def mean
     get_mean(self)
@@ -12,4 +15,9 @@ class Array
   def median
     get_median(self)
   end
+
+  def unique_mode
+    get_unique_mode(self)
+  end
+
 end

data/lib/average/average_helper.rb

@@ -1,43 +1,46 @@
-def valid_array?(array)
-  # Valid if:
-  # - the class of the parameter 'array' respond to Array
-  # - the parameter 'Array' is not null or empty.
-  # - The array given contains Integers, Floats, and Strings that could be turned to a valid digit.
-  ( array.is_a?(Array) && !array.nil? && !array.empty? && array_contain_digits?(array) )
-end
+module AverageHelper
+  def valid_array?(array)
+    # Valid if:
+    # - the class of the parameter 'array' respond to Array
+    # - the parameter 'Array' is not null or empty.
+    # - The array given contains Integers, Floats, and Strings that could be turned to a valid digit.
+    ( array.is_a?(Array) && !array.nil? && !array.empty? && array_contain_digits?(array) )
+  end
 
-def array_contain_digits?(array)
-  # Go through all elements
-  result = true
-  array.each do |array_element|
-    if not value_can_be_handled?(array_element)
-      result = false
+  def array_contain_digits?(array)
+    # Go through all elements
+    result = true
+    array.each do |array_element|
+      if !value_can_be_handled?(array_element)
+        result = false
+      end
     end
+    result
   end
-  result
-end
 
-def value_can_be_handled?(element)
-  # Check if the elements of the array 'look like numbers'.
-  element.is_a?(Integer) || element.is_a?(Float) || looks_like_a_digit?(element)
-end
+  def value_can_be_handled?(element)
+    # Check if the elements of the array 'look like numbers'.
+    element.is_a?(Integer) || element.is_a?(Float) || looks_like_a_digit?(element)
+  end
 
 
-def looks_like_a_digit?(digit)
-  if digit.is_a?(String) && digit !~ /^\s*[+-]?((\d+_?)*\d+(\.(\d+_?)*\d+)?|\.(\d+_?)*\d+)(\s*|([eE][+-]?(\d+_?)*\d+)\s*)$/
-    # is _not_ a string that could be turned to a digit
-    false
-  else
-    # is a string that could be a digit
-    true
+  def looks_like_a_digit?(digit)
+    if digit.is_a?(String) && digit !~ /^\s*[+-]?((\d+_?)*\d+(\.(\d+_?)*\d+)?|\.(\d+_?)*\d+)(\s*|([eE][+-]?(\d+_?)*\d+)\s*)$/
+      # is _not_ a string that could be turned to a digit
+      false
+    else
+      # is a string that could be a digit
+      true
+    end
   end
-end
 
-def clean_array(array)
-  array.each_with_index do |val, index|
-    if val.is_a?(String)
-      val.include?('.') ? (array[index] = val.to_f) : (array[index] = val.to_i)
+  def clean_array(array)
+    array.each_with_index do |val, index|
+      if val.is_a?(String)
+        val.include?('.') ? (array[index] = val.to_f) : (array[index] = val.to_i)
+      end
     end
+    array
   end
-  array
+
 end

data/lib/average/mean.rb

@@ -1,5 +1,7 @@
-def get_mean(array)
-  return if not valid_array?(array)
-  array = clean_array(array)
-  array.inject(0) { |sum, x| sum += x } / array.size.to_f
+module Mean
+  def get_mean(array)
+    if valid_array?(array)
+      clean_array(array).inject(0) { |sum, x| sum += x } / array.size.to_f
+    end
+  end
 end

data/lib/average/median.rb

@@ -1,22 +1,24 @@
-def get_median(array)
-  return if not valid_array?(array)
-  array = clean_array(array)
-  calculate_median(array)
-end
+module Median
+  def get_median(array)
+    if valid_array?(array)
+      calculate_median(clean_array(array))
+    end
+  end
 
-def calculate_median(array)
-  array.sort!
-  if array.length.even?
-    get_mean( middle_items_to_average(array) )
-  else
-    array[ array.length / 2.to_f ]
+  def calculate_median(array)
+    array.sort!
+    if array.length.even?
+      get_mean( middle_items_to_average(array) )
+    else
+      array[ array.length / 2.to_f ]
+    end
   end
-end
 
-def middle_item(array)
-  array.size / 2
-end
+  def middle_item(array)
+    array.size / 2
+  end
 
-def middle_items_to_average(array)
-  array[ middle_item(array) -1 .. middle_item(array) ]
+  def middle_items_to_average(array)
+    array[ middle_item(array) -1 .. middle_item(array) ]
+  end
 end

data/lib/average/mode.rb

@@ -1,20 +1,33 @@
-def get_mode(array)
-  return if not valid_array?(array)
-  array  = clean_array(array)
-  result = repetition_hash(array)
-  result[:hash_result].select { |key, value| value == result[:max_repetition] }.keys.collect { |float| float.to_i }
-end
+module Mode
+  def get_mode(array)
+    if valid_array?(array)
+      result = repetition_hash( clean_array(array) )
+      if build_hash_result(result).count > 1
+        # It contains more than one mode
+        build_hash_result(result).keys.collect { |float| float.to_i }
+      else
+        # It contains only one mode
+        build_hash_result(result).keys.first
+      end
+    end
+  end
 
-def repetition_hash(array)
-  return if !valid_array?(array)
-  array  = clean_array(array)
-  result = array.inject({}) { |key, value| key[value] = array.count(value.to_f); key }
-  { hash_result: result, max_repetition: result.values.max }
-end
+  def repetition_hash(array)
+    { hash_result: build_repetition_result(array), max_repetition: build_repetition_result(array).values.max }
+  end
 
-def unique_mode(array)
-  # only for Ruby versions bigger than 1.8.7 -> http://apidock.com/ruby/v1_8_7_72/Enumerable/max_by
-  return if !valid_array?(array)
-  array  = clean_array(array)
-  array.max_by { |x| array.count(x) }
+  def build_hash_result(result)
+    result[:hash_result].select { |key, value| value == result[:max_repetition] }
+  end
+
+  def build_repetition_result(array)
+     array.inject({}) { |key, value| key[value] = array.count(value.to_f); key }
+  end
+
+  def get_unique_mode(array)
+    # only for Ruby versions bigger than 1.8.7 -> http://apidock.com/ruby/v1_8_7_72/Enumerable/max_by
+    if valid_array?(array)
+      clean_array(array).max_by { |x| clean_array(array).count(x) }
+    end
+  end
 end

data/lib/average/version.rb

@@ -1,3 +1,3 @@
-module Average
-  VERSION = "3.0"
+class Average
+  VERSION = "3.1"
 end

data/spec/array_overrides_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Average do
 
-  let(:int_array)   { [3,4,5]                  }
+  let(:int_array)   { [3,4,5] }
 
   describe '.mean' do
     context 'should give back the same result as' do
@@ -28,4 +28,12 @@ describe Average do
     end
   end
 
+  describe '.unique_mode' do
+    context 'should give back the same result as ' do
+      it 'get_unique_mode([X,X,X,X])' do
+       expect(int_array.unique_mode).to eq(get_unique_mode(int_array))
+      end
+    end
+  end
+
 end

data/spec/average_helper_spec.rb

@@ -97,11 +97,11 @@ describe Average do
   end
 
   describe '#clean_array' do
-    context 'with an array that contains valid that could be converted to a digit' do
+    context 'with an array that has a valid mixed-array structure' do
       it 'should return an array without string and with the correct numeric format' do
         expect(clean_array(valid_array)).to eq([3, 4.0, 5, 2, 0.3])
       end
     end
   end
 
-end
+end

data/spec/mode_spec.rb

@@ -7,6 +7,8 @@ describe Average do
   let(:mode_array)  { [1,1,2,2,3,4]            }
 
   let(:mixed_array) { [3, 4.0, 5, 2.0, 3, 1.0] }
+  let(:array_with_two_modes) { [1, 2, 2, 2, 3, 3, 7, 7, 7, 9] }
+  let(:array_with_one_mode)  { [2, 4, 6, 14, 21, 24, 229, 24, 24, 39] }
 
   describe '#get_mode' do
 
@@ -17,36 +19,36 @@ describe Average do
     end
 
     context 'with a empty array' do
-      it 'should return a empty array' do
+      it 'should return nil' do
         expect(get_mode([])).to eq(nil)
       end
     end
 
     context 'with a nil object' do
-      it 'should return a empty array' do
+      it 'should return a nil' do
         expect(get_mode([])).to eq(nil)
       end
     end
 
   end
 
-  describe '#unique_mode' do
+  describe '#get_unique_mode' do
 
     context 'with a array of integers' do
       it 'should calculate the correct mode returning only one mode' do
-        expect(unique_mode(mode_array)).to eq(1)
+        expect(get_unique_mode(mode_array)).to eq(1)
       end
     end
 
     context 'with a empty array' do
       it 'should return nil' do
-        expect(unique_mode([])).to eq(nil)
+        expect(get_unique_mode([])).to eq(nil)
       end
     end
 
     context 'with a nil object' do
       it 'should return nil' do
-        expect(unique_mode(nil)).to eq(nil)
+        expect(get_unique_mode(nil)).to eq(nil)
       end
     end
 
@@ -71,17 +73,26 @@ describe Average do
     end
 
     context 'with a empty array' do
-      it 'should return nil' do
-        expect(repetition_hash([])).to eql(nil)
+      it 'should return a hash with empty values' do
+        expect(repetition_hash([])).to eql({:hash_result=>{}, :max_repetition=>nil})
       end
     end
 
-    context 'with a empty array' do
-      it 'should return nil' do
-        expect(repetition_hash(nil)).to eql(nil)
+  end
+
+  describe 'testing returned values' do
+
+    context 'with an array that has two modes' do
+      it 'should return an array with two values' do
+        expect(get_mode(array_with_two_modes)).to eq([2, 7])
       end
     end
 
+    context 'with an array that has one modes' do
+      it 'should return an array with two values' do
+        expect(get_mode(array_with_one_mode)).to eq(24)
+      end
+    end
   end
 
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: average
 version: !ruby/object:Gem::Version
-  version: '3.0'
+  version: '3.1'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-01 00:00:00.000000000 Z
+date: 2015-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler