utilities 0.0.14 → 0.0.15

data/lib/utilities/array.rb

@@ -0,0 +1,39 @@
+class Array
+  # Returns true if the array contains only numerical values
+  def numerics?( allow_nil = false )
+    (allow_nil ? compact : self).reject{ |x| x.is_a?( Numeric ) }.empty?
+  end
+  alias_method :numeric?, :numerics?
+  alias_method :narray?, :numerics?
+  
+  # Transforms an array
+  def to_numerics
+    map{ |x| x.to_f }
+  end
+  alias_method :to_numeric, :to_numerics
+  alias_method :to_narray, :to_numerics
+  
+  # Returns a copy of self reverse sorted
+  def reverse_sort
+    dup.rsort!
+  end
+  alias_method :rsort, :reverse_sort
+  
+  # Reverse sort self
+  def reverse_sort!
+    sort!{|x,y| y <=> x }
+  end
+  alias_method :rsort!, :reverse_sort!
+  
+  # Returns a copy of self that includes the Statistics methods
+  def to_stat
+    dup.to_stat!
+  end
+  alias_method :to_stats, :to_stat
+  
+  # Adds the statistics methods to self
+  def to_stat!
+    extend(Utilities::Statistics)
+  end
+  alias_method :to_stats!, :to_stat!
+end

data/lib/utilities/datetime.rb

@@ -0,0 +1,6 @@
+class DateTime
+  # Transform a DateTime to a Time
+  def to_time
+    Time.parse(self.to_s)
+  end
+end

data/lib/utilities/enumerable.rb

@@ -0,0 +1,19 @@
+module Enumerable  
+  # Collects the first N truthy values
+  # {}.collect_first {|a, b| obj} => obj
+  # {}.collect_first(n) {|a, b| obj} => [obj]
+  def collect_first( amount = nil, &block )
+    array = !amount.nil?
+    amount ||= 1
+    
+    values = []
+    self.each do |val|
+      break if values.length >= amount
+      t = yield(val)
+      values << t if t
+    end
+    
+    !array && amount == 1 ? values.first : values
+  end
+  alias_method :map_first, :collect_first
+end

data/lib/utilities/hash.rb

@@ -0,0 +1,18 @@
+class Hash
+  # Returns a new hash with the results of running block once for every key in self
+  def collect_keys
+    each_with_object({}){ |(k,v),h| h[yield(k)] = v } if block_given?
+  end
+  alias_method :map_keys, :collect_keys
+  
+  # Returns a new hash with the results of running block once for every value in self
+  def collect_values
+    each_with_object({}){ |(k,v),h| h[k] = yield(v) } if block_given?
+  end
+  alias_method :map_values, :collect_values
+  
+  # Returns a new hash where all keys have been symbolized
+  def symbolize_keys
+    collect_keys{ |k| k.to_sym }
+  end
+end

data/lib/utilities/kernel.rb

@@ -0,0 +1,6 @@
+module Kernel
+  # Add .inspect to any object passed, than call Kernel.raise
+  def raiser(*args)
+    raise args.collect(&:inspect).join(", ")
+  end
+end

data/lib/utilities/numeric.rb

@@ -0,0 +1,40 @@
+class Numeric
+  # Convert to degrees
+  def degrees
+    self * Math::PI / 180
+  end
+  
+  # Return the square of self
+  def square
+    self * self
+  end
+  
+  #Transform self to a string formatted time (HH:MM) Ex: 14.5 => “14:30“
+  def hour_to_string delimiter = ':'
+    hour  = self.to_i
+    min   = "%02d" % (self.abs * 60 % 60).to_i
+    "#{hour}#{delimiter}#{min}"
+  end
+  
+  # Return the square root of self
+  def sqrt
+    Math.sqrt(self)
+  end
+  
+  # Calculate the rank of self based on provided min and max
+  def rank min, max
+    s, min, max = self.to_f, min.to_f, max.to_f
+    min == max ? 0.0 : (s - min) / (max - min)
+  end
+  
+  # Transforms self to a string with *decimals* decimals
+  def to_decimals decimals = 2
+    "%.#{decimals}f" % self
+  end
+  
+  # Calculate the percentage of self on n
+  def percentage_of n, t = 100
+    n == 0 ? 0.0 : self / n.to_f * t
+  end
+  alias_method :percent_of, :percentage_of
+end

data/lib/utilities/object.rb

@@ -0,0 +1,9 @@
+class Object
+  def within? enumerable
+    if enumerable.is_a? Range
+      enumerable.cover?(self)
+    else
+      enumerable.min <= self && self <= enumerable.max
+    end
+  end
+end

data/lib/utilities/range.rb

@@ -0,0 +1,24 @@
+class Range
+  # Return a range containing elements common to the two ranges, with no duplicates
+  def intersection range
+    values = self.to_a & range.to_a
+    values.empty? ? nil : (values.first..values.last)  
+  end  
+  alias_method :&, :intersection
+  
+  # Verify if self is empty
+  def empty?
+    count.zero?
+  end
+  
+  # Detect if the two ranges overlap one with the other
+  def overlap? range
+    !(self & range).nil?
+  end
+  
+  # Adds cover? if not defined (like in previous rubies)
+  def cover? object
+    ends = [self.first, self.last]
+    ends.min <= object && object <= ends.max
+  end unless self.instance_methods.include?(:cover?)
+end

data/lib/utilities/string.rb

@@ -0,0 +1,11 @@
+class String  
+  # Transform self to a Date
+  def to_date
+    Date.parse(self)
+  end
+  
+  # Transform self to a Time
+  def to_time
+    Time.parse(self)
+  end
+end

data/lib/utilities/time.rb

@@ -0,0 +1,7 @@
+class Time  
+  # Transform a Time to a DateTime
+  def to_datetime
+    DateTime.parse(self.to_s)
+  end
+end
+

data/lib/utilities/utilities.rb

@@ -0,0 +1,169 @@
+module Utilities
+  module Submodules
+    # Find every submodules of an object.
+    def submodules
+      constants.collect{ |const_name| const_get(const_name) }.select{ |const| const.class == Module }
+    end
+  end
+  
+  module Subclasses    
+    # Find every subclass of an object.
+    def subclasses(direct = false)
+      classes = []
+      
+      if direct
+        ObjectSpace.each_object(Class) do |c|
+          classes << c if c.superclass == self
+        end
+      else
+        ObjectSpace.each_object(Class) do |c|
+          classes << c if c.ancestors.include?(self) and (c != self)
+        end
+      end
+      
+      classes
+    end
+  end
+  
+  module Statistics
+    # Add each object of the array to each other in order to get the sum, as long as all objects respond to + operator
+    def sum
+      flatten.compact.inject( :+ )
+    end
+    
+    # Calculate squares of each item
+    def squares
+      map{ |i| i**2 }
+    end
+    
+    # Return a new array containing the rank of each value
+    # Ex: [1, 2, 2, 8, 9] #=> [0.0, 1.5, 1.5, 3.0, 4.0]
+    def ranks( already_sorted = false )
+      a = already_sorted ? self : sort
+      map{ |i| (a.index(i) + a.rindex(i)) / 2.0 }
+    end
+    
+    # Calculate square roots of each item
+    def sqrts
+      map{ |i| i.sqrt }
+    end
+    
+    # Calculate the mean of the array, as long as all objects respond to / operator
+    def mean
+      a = flatten.compact.to_stat
+      (a.size > 0) ? a.sum.to_f / a.size : 0.0
+    end
+    alias_method :average, :mean
+    
+    # Calculate the number of occurences for each element of the array
+    def frequences
+      inject(Hash.new(0)) { |h, v| h[v] += 1; h }
+    end
+    
+    # Return the variance of self
+    def variance
+      m = mean
+      inject(0) { |v, x| v += (x - m) ** 2 }
+    end
+    
+    # Return the (sample|population) standard deviation of self
+    # If population is set to true, then we consider the dataset as the complete population
+    # Else, we consider the dataset as a sample, so we use the sample standard deviation (size - 1)
+    def standard_deviation( population = false )
+      size > 1 ? Math.sqrt( variance / ( size - ( population ? 0 : 1 ) ) ) : 0.0
+    end
+    alias_method :std_dev, :standard_deviation
+    
+    # Return the median of sorted self
+    def median( already_sorted = false )
+      return nil if empty?
+      a = sort_and_extend( already_sorted )
+      m_pos = size / 2
+      size % 2 == 1 ? a[m_pos] : (a[m_pos-1] + a[m_pos]).to_f / 2
+    end
+    alias_method :second_quartile, :median
+    
+    # Return the first quartile of self
+    def first_quartile( already_sorted = false )
+      return nil if size < 4
+      a = already_sorted ? self : sort
+      a[0..((size / 2) - 1)].extend(Utilities::Statistics).median( true )
+    end
+    alias_method :lower_quartile, :first_quartile
+    
+    # Return the last quartile of self
+    def last_quartile( already_sorted = false )
+      return nil if size < 4
+      a = already_sorted ? self : sort
+      a[((size / 2) + 1)..-1].extend(Utilities::Statistics).median( true )
+    end
+    alias_method :upper_quartile, :last_quartile
+    
+    # Return an array containing the first, the second and the last quartile of self
+    def quartiles( already_sorted = false )
+      a = sort_and_extend( already_sorted )
+      [a.first_quartile( true ), a.median( true ), a.last_quartile( true )]
+    end
+    
+    # Calculate the interquartile range of self
+    def interquartile_range( already_sorted = false )
+      return nil if size < 4
+      a = sort_and_extend( already_sorted )
+      a.last_quartile - a.first_quartile
+    end
+    
+    # Return an array of modes with their corresponding occurences
+    def modes
+      fre = frequences
+      max = freq.values.max
+      fre.select{ |k, f| f == max }
+    end
+    
+    # Return the midrange of sorted self
+    def midrange( already_sorted = false )
+      return nil if empty?
+      a = sort_and_extend( already_sorted )
+      (a.first + a.last) / 2.0
+    end
+    
+    # Return the statistical range of sorted self
+    def statistical_range( already_sorted = false )
+      return nil if empty?
+      a = sort_and_extend( already_sorted )
+      (a.last - a.first)
+    end
+    
+    # Return all statistics from self in a simple hash
+    def statistics( already_sorted = false )
+      sorted = sort_and_extend( already_sorted )
+      
+      {
+        :first => self.first,
+        :last => self.last,
+        :size => self.size,
+        :sum => self.sum,
+        :min => self.min,
+        :max => self.max,
+        :mean => self.mean,
+        :frequences => self.frequences,
+        :variance => self.variance,
+        :standard_deviation => self.standard_deviation,
+        :modes => self.modes,
+        
+        # Need to be sorted...
+        :ranks => sorted.ranks( true ),
+        :median => sorted.median( true ),
+        :midrange => sorted.midrange( true ),
+        :statistical_range => sorted.statistical_range( true ),
+        :quartiles => sorted.quartiles( true ),
+        :interquartile_range => sorted.interquartile_range( true )
+      }
+    end
+    alias_method :stats, :statistics
+    
+    protected
+      def sort_and_extend( already_sorted = false )
+        already_sorted ? self : sort.extend(Utilities::Statistics)
+      end
+  end
+end

data/lib/version.rb

@@ -1,7 +1,7 @@
 class Utilities
   MAJOR = 0
   MINOR = 0
-  BUILD = 14
+  BUILD = 15
 
   VERSION = "#{MAJOR}.#{MINOR}.#{BUILD}"
 end

data/utilities.gemspec

@@ -14,13 +14,7 @@ Gem::Specification.new do |s|
   s.summary     = "Few utilities include in all my projects"
   s.description = "Few utilities include in all my projects, including a module for statistics, some to_date and to_time functions as well as intersection method for Range object."
  
-  s.files = [
-    'LICENSE',
-    'README',
-    'utilities.gemspec',
-    'lib/utilities.rb',
-    'lib/version.rb',
-    'test/test_utilities.rb']
+  s.files = `git ls-files`.split("\n")
   
   s.require_paths = ['lib', 'test']
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: utilities
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.15
   prerelease: 
 platform: ruby
 authors:
@@ -24,10 +24,22 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README
-- utilities.gemspec
 - lib/utilities.rb
+- lib/utilities/array.rb
+- lib/utilities/datetime.rb
+- lib/utilities/enumerable.rb
+- lib/utilities/hash.rb
+- lib/utilities/kernel.rb
+- lib/utilities/numeric.rb
+- lib/utilities/object.rb
+- lib/utilities/range.rb
+- lib/utilities/string.rb
+- lib/utilities/time.rb
+- lib/utilities/utilities.rb
 - lib/version.rb
 - test/test_utilities.rb
+- utilities-0.0.14.gem
+- utilities.gemspec
 homepage: http://github.com/christianblais/utilities
 licenses: []
 post_install_message: