everyday-cli-utils 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f620a7c1e67d6366c45323874f2346bf710ce9b6
-  data.tar.gz: 96c78fb64efef0e03dc1bf26b6f1d8a9e7b2d49f
+  metadata.gz: ec3b8b4933935c4c8f32696a300d9e03b10aeb0a
+  data.tar.gz: 6af1473a8f38fabec5097d9666a6972cd728834f
 SHA512:
-  metadata.gz: 5982ac1f4c14e8321e82b9b5c5d194226cd5721f08148d09d896c5d5e17edc6bd29ef450df64f3bc510988da0778a95822531829eff1fc20d3563c15f364564d
-  data.tar.gz: a54b86c5ca17e02dab387bfcf12550b2c32b34effa6b3d762e06ed124a891bb5980e3ca05da192445230064e41d87032d8e59573a20381cd413e9d2fd0c04f24
+  metadata.gz: a56b940fd967714110f57b70e47b1178ce069685cf03fba4d55cc9859e23d0f284fab303c5d0eb6d6f22926e2ede774f04fc317d21a45277743b8dfa40628290
+  data.tar.gz: b52ad9d742d1cc507cde63bbb7ae6bd270a268f999ccdeaa022d7d5505fe0a8a052580d3e7a87502039f97c525857d48ed0c73a90e9baf58045c8156fb76c4a2

data/README.md

@@ -1,6 +1,8 @@
 # EverydayCliUtils
 
+[![Gem Version](https://badge.fury.io/rb/everyday-cli-utils.png)](http://badge.fury.io/rb/everyday-cli-utils)
 [![Build Status](https://travis-ci.org/henderea/everyday-cli-utils.png?branch=master)](https://travis-ci.org/henderea/everyday-cli-utils)
+[![Dependency Status](https://gemnasium.com/henderea/everyday-cli-utils.png)](https://gemnasium.com/henderea/everyday-cli-utils)
 [![Code Climate](https://codeclimate.com/github/henderea/everyday-cli-utils.png)](https://codeclimate.com/github/henderea/everyday-cli-utils)
 [![Coverage Status](https://coveralls.io/repos/henderea/everyday-cli-utils/badge.png?branch=master)](https://coveralls.io/r/henderea/everyday-cli-utils?branch=master)
 

data/lib/everyday-cli-utils/curses_utils.rb

@@ -1,38 +1,40 @@
-module CursesUtils
-  COLOR_TO_CURSES = {
-      :black  => Curses::COLOR_BLACK,
-      :red    => Curses::COLOR_RED,
-      :green  => Curses::COLOR_GREEN,
-      :yellow => Curses::COLOR_YELLOW,
-      :blue   => Curses::COLOR_BLUE,
-      :purple => Curses::COLOR_MAGENTA,
-      :cyan   => Curses::COLOR_CYAN,
-      :white  => Curses::COLOR_WHITE,
-      :none   => -1,
-  }
+module EverydayCliUtils
+  module CursesUtils
+    COLOR_TO_CURSES = {
+        :black  => Curses::COLOR_BLACK,
+        :red    => Curses::COLOR_RED,
+        :green  => Curses::COLOR_GREEN,
+        :yellow => Curses::COLOR_YELLOW,
+        :blue   => Curses::COLOR_BLUE,
+        :purple => Curses::COLOR_MAGENTA,
+        :cyan   => Curses::COLOR_CYAN,
+        :white  => Curses::COLOR_WHITE,
+        :none   => -1,
+    }
 
-  def find_color(bgcolor, fgcolor)
-    @colors.find_index { |v| v[0] == (fgcolor || :none) && v[1] == (bgcolor || :none) }
-  end
+    def find_color(bgcolor, fgcolor)
+      @colors.find_index { |v| v[0] == (fgcolor || :none) && v[1] == (bgcolor || :none) }
+    end
 
-  def add_color(bgcolor, fgcolor)
-    Curses::init_pair(@colors.count + 1, COLOR_TO_CURSES[fgcolor || :none], COLOR_TO_CURSES[bgcolor || :none])
-    ind = @colors.count + 1
-    @colors << [fgcolor || :none, bgcolor || :none]
-    ind
-  end
+    def add_color(bgcolor, fgcolor)
+      Curses::init_pair(@colors.count + 1, COLOR_TO_CURSES[fgcolor || :none], COLOR_TO_CURSES[bgcolor || :none])
+      ind = @colors.count + 1
+      @colors << [fgcolor || :none, bgcolor || :none]
+      ind
+    end
 
 
-  private
-  def handle_color(fgcolor, bgcolor)
-    return 0 if (fgcolor.nil? || fgcolor == :none) && (bgcolor.nil? || bgcolor == :none)
-    ind = find_color(bgcolor, fgcolor)
-    ind = ind.nil? ? add_color(bgcolor, fgcolor) : ind + 1
-    Curses::color_pair(ind)
-  end
+    private
+    def handle_color(fgcolor, bgcolor)
+      return 0 if (fgcolor.nil? || fgcolor == :none) && (bgcolor.nil? || bgcolor == :none)
+      ind = find_color(bgcolor, fgcolor)
+      ind = ind.nil? ? add_color(bgcolor, fgcolor) : ind + 1
+      Curses::color_pair(ind)
+    end
 
-  def get_format(str)
-    bold, underline, fgcolor, bgcolor = Format::parse_format(str)
-    (bold ? Curses::A_BOLD : 0) | (underline ? Curses::A_UNDERLINE : 0) | handle_color(fgcolor, bgcolor)
+    def get_format(str)
+      bold, underline, fgcolor, bgcolor = Format::parse_format(str)
+      (bold ? Curses::A_BOLD : 0) | (underline ? Curses::A_UNDERLINE : 0) | handle_color(fgcolor, bgcolor)
+    end
   end
-end
+end

data/lib/everyday-cli-utils/format.rb

@@ -1,110 +1,4 @@
-module EverydayCliUtils
-  module Format
-    def self.build_format_hash(first_chr)
-      {
-          :black  => "#{first_chr}0",
-          :red    => "#{first_chr}1",
-          :green  => "#{first_chr}2",
-          :yellow => "#{first_chr}3",
-          :blue   => "#{first_chr}4",
-          :purple => "#{first_chr}5",
-          :cyan   => "#{first_chr}6",
-          :white  => "#{first_chr}7",
-          :none   => nil,
-      }
-    end
-
-    FORMAT_TO_CODE   = {
-        :bold      => '1',
-        :underline => '4',
-    }
-    FG_COLOR_TO_CODE = build_format_hash('3')
-    BG_COLOR_TO_CODE = build_format_hash('4')
-
-    def self::format(text, format_code)
-      (format_code.nil? || format_code == '') ? text : "\e[#{format_code}m#{text}\e[0m"
-    end
-
-    def self::build_string(bold, underline, fgcolor, bgcolor)
-      str      = ''
-      hit      = false
-      hit, str = handle_bold(bold, hit, str)
-      hit, str = handle_underline(hit, str, underline)
-      hit, str = handle_fg_color(fgcolor, hit, str)
-      handle_bg_color(bgcolor, hit, str)
-    end
-
-    def self.handle_bold(bold, hit, str)
-      if bold
-        hit = true
-        str = FORMAT_TO_CODE[:bold]
-      end
-      return hit, str
-    end
-
-    def self.handle_underline(hit, str, underline)
-      if underline
-        str += ';' if hit
-        hit = true
-        str += FORMAT_TO_CODE[:underline]
-      end
-      return hit, str
-    end
-
-    def self.handle_fg_color(fgcolor, hit, str)
-      unless fgcolor.nil? || FG_COLOR_TO_CODE[fgcolor].nil?
-        str += ';' if hit
-        hit = true
-        str += FG_COLOR_TO_CODE[fgcolor]
-      end
-      return hit, str
-    end
-
-    def self.handle_bg_color(bgcolor, hit, str)
-      unless bgcolor.nil? || BG_COLOR_TO_CODE[bgcolor].nil?
-        str += ';' if hit
-        str += BG_COLOR_TO_CODE[bgcolor]
-      end
-      str
-    end
-
-    def self::parse_format(str)
-      parts     = str.split(';')
-      bold      = false
-      underline = false
-      fgcolor   = :none
-      bgcolor   = :none
-      parts.each { |v|
-        if v == FORMAT_TO_CODE[:bold]
-          bold = true
-        elsif v == FORMAT_TO_CODE[:underline]
-          underline = true
-        elsif v[0] == '3'
-          fgcolor = FG_COLOR_TO_CODE.invert[v]
-        elsif v[0] == '4'
-          bgcolor = BG_COLOR_TO_CODE.invert[v]
-        end
-      }
-      return bold, underline, fgcolor, bgcolor
-    end
-
-    def self::colorize(text, fgcolor = nil, bgcolor = nil)
-      self::format(text, self::build_string(false, false, fgcolor, bgcolor))
-    end
-
-    def self::bold(text, fgcolor = nil, bgcolor = nil)
-      self::format(text, self::build_string(true, false, fgcolor, bgcolor))
-    end
-
-    def self::underline(text, fgcolor = nil, bgcolor = nil)
-      self::format(text, self::build_string(false, true, fgcolor, bgcolor))
-    end
-
-    def self::boldunderline(text, fgcolor = nil, bgcolor = nil)
-      self::format(text, self::build_string(true, true, fgcolor, bgcolor))
-    end
-  end
-end
+require_relative 'safe/format'
 
 class String
   alias :old_method_missing :method_missing

data/lib/everyday-cli-utils/histogram.rb

@@ -1,43 +1,7 @@
-require_relative 'maputil'
-
-module EverydayCliUtils
-  class Histogram
-    def self.setup(collection, height, width)
-      mi     = collection.min
-      ma     = collection.max
-      diff   = ma - mi
-      step   = diff.to_f / (width.to_f - 1)
-      counts = Array.new(width, 0)
-      collection.each { |v| counts[((v - mi).to_f / step.to_f).floor] += 1 }
-      max_y = counts.max
-      lines = Array.new(height) { ' ' * width }
-      return counts, lines, max_y, mi, step
-    end
-
-    def self.add_graph(counts, height, lines, max_y, width)
-      (0...width).each { |i|
-        h = ((counts[i].to_f / max_y.to_f) * height.to_f).round
-        ((height - h)...height).each { |j|
-          lines[j][i] = '#'
-        }
-        if h == 0 && counts[i] > 0
-          lines[height - 1][i] = '_'
-        end
-      }
-    end
-
-    def self.add_averages(height, ks, lines, mi, step, width)
-      lines[height] = ' ' * width
-      ks.each { |v| lines[height][((v - mi) / step).to_i] = '|' }
-    end
-  end
-end
+require_relative 'safe/histogram'
 
 module Enumerable
   def histogram(ks = nil, width = 100, height = 50)
-    counts, lines, max_y, mi, step = EverydayCliUtils::Histogram.setup(self, height, width)
-    EverydayCliUtils::Histogram.add_graph(counts, height, lines, max_y, width)
-    EverydayCliUtils::Histogram.add_averages(height, ks, lines, mi, step, width) unless ks.nil?
-    lines
+    EverydayCliUtils::Histogram.histogram(self, ks, width, height)
   end
 end

data/lib/everyday-cli-utils/kmeans.rb

@@ -1,154 +1,19 @@
-require_relative 'maputil'
-
-module EverydayCliUtils
-  class Kmeans
-    def self.normal(x, avg, std)
-      exp = -(((x - avg) / std) ** 2.0) / 2.0
-      ((Math.exp(exp) / (std * Math.sqrt(2.0 * Math::PI))))
-    end
-
-    def self.f_test(clusters, means, cnt, avg)
-      cnt2 = clusters.count { |i| !i.empty? }
-      ev   = f_test_ev(avg, clusters, cnt2, means)
-      uv   = f_test_uv(clusters, cnt, cnt2, means)
-      (ev / uv)
-    end
-
-    def self.f_test_ev(avg, clusters, cnt2, means)
-      ev = 0.0
-      (0...means.count).each { |i| ev += clusters[i].empty? ? 0.0 : clusters[i].count * ((means[i] - avg) ** 2.0) }
-      ev / (cnt2 - 1.0)
-    end
-
-    def self.f_test_uv(clusters, cnt, cnt2, means)
-      uv = 0.0
-      (0...means.count).each { |i|
-        unless clusters[i].empty?
-          (0...clusters[i].count).each { |j|
-            uv += (clusters[i][j] - means[i]) * (clusters[i][j] - means[i])
-          }
-        end
-      }
-      uv / (cnt - cnt2)
-    end
-
-    def self.f_test2(clusters, means, cnt)
-      uv   = 0.0
-      cnt2 = clusters.count { |i| !i.empty? }
-      (0...means.count).each { |i| uv += f_test2_calc(clusters, i, means, uv) unless clusters[i].empty? }
-      (uv / (cnt - cnt2))
-    end
-
-    def self.f_test2_calc(clusters, i, means, uv)
-      tmp = 0.0
-      (0...clusters[i].count).each { |j|
-        tmp += (clusters[i][j] - means[i]) ** 2.0
-      }
-      tmp /= clusters[i].count
-      Math.sqrt(tmp)
-    end
-
-    def self.nmeans_setup_1(collection)
-      su  = collection.sum
-      cnt = collection.count
-      avg = su / cnt
-      ks1 = collection.kmeans(1)
-      return avg, cnt, ks1
-    end
-
-    def self.nmeans_setup_2(collection, avg, cnt, ks1)
-      cso = collection.get_clusters(ks1)
-      ft1 = f_test2(cso, ks1, cnt)
-      ks  = collection.kmeans(2)
-      cs  = collection.get_clusters(ks)
-      ft  = f_test(cs, ks, cnt, avg)
-      ft2 = f_test2(cs, ks, cnt)
-      return ft, ft1, ft2, ks
-    end
-
-    def self.run_nmean(collection, avg, cnt, ft, ft2, k, ks)
-      kso  = ks
-      fto  = ft
-      fto2 = ft2
-      ks   = collection.kmeans(k)
-      cs   = collection.get_clusters(ks)
-      ft   = f_test(cs, ks, cnt, avg)
-      ft2  = f_test2(cs, ks, cnt)
-      return ft, ft2, fto, fto2, ks, kso
-    end
-
-    def self.run_nmeans(avg, cnt, collection, ft, ft1, ft2, ks, ks1, max_k, threshold)
-      (3..[max_k, cnt].min).each { |k|
-        ft, ft2, fto, fto2, ks, kso = run_nmean(collection, avg, cnt, ft, ft2, k, ks)
-        return kso if ((ft - fto) / fto) < threshold && fto2 < ft1
-      }
-      ft2 >= ft1 ? ks1 : ks
-    end
-
-    def self.run_kmean(collection, ks)
-      kso      = ks
-      clusters = collection.get_clusters(kso)
-      ks       = []
-      clusters.each_with_index { |val, key| ks[key] = (val.count <= 0) ? kso[key] : (val.sum / val.count) }
-      ks.sort
-      return kso, ks
-    end
-  end
-end
+require_relative 'safe/kmeans'
 
 module Enumerable
   def outliers(sensitivity = 0.5, k = nil)
-    ks = k.nil? ? nmeans : kmeans(k)
-    cs = get_clusters(ks)
-
-    outliers = []
-
-    ks.each_with_index { |avg, i| outliers += find_outliers(avg, cs, i, sensitivity) }
-    outliers
-  end
-
-  def find_outliers(avg, cs, i, sensitivity)
-    csi = cs[i]
-    std = csi.std_dev
-    cnt = csi.count
-    csi.select { |c| (EverydayCliUtils::Kmeans.normal(c, avg, std) * cnt) < sensitivity }
+    EverydayCliUtils::Kmeans.outliers(self, sensitivity, k)
   end
 
   def nmeans(max_k = 10, threshold = 0.05)
-    collection    = self.floats
-    avg, cnt, ks1 = EverydayCliUtils::Kmeans.nmeans_setup_1(collection)
-    return ks1 if cnt == 1
-    ft, ft1, ft2, ks = EverydayCliUtils::Kmeans.nmeans_setup_2(collection, avg, cnt, ks1)
-    EverydayCliUtils::Kmeans.run_nmeans(avg, cnt, collection, ft, ft1, ft2, ks, ks1, max_k, threshold)
+    EverydayCliUtils::Kmeans.nmeans(self, max_k, threshold)
   end
 
   def kmeans(k)
-    mi   = min
-    ma   = max
-    diff = ma - mi
-    ks   = []
-    (1..k).each { |i| ks[i - 1] = mi + (i * (diff / (k + 1.0))) }
-    kso = false
-    while ks != kso
-      kso, ks = EverydayCliUtils::Kmeans.run_kmean(self, ks)
-    end
-    ks
+    EverydayCliUtils::Kmeans.kmeans(self, k)
   end
 
   def get_clusters(means)
-    clusters = Array.new(means.count) { Array.new }
-    each { |item|
-      cluster  = false
-      distance = false
-      (0...means.count).each { |i|
-        diff = (means[i] - item).abs
-        if distance == false || diff < distance
-          cluster  = i
-          distance = diff
-        end
-      }
-      clusters[cluster][clusters[cluster].count] = item
-    }
-    clusters
+    EverydayCliUtils::Kmeans.get_clusters(self, means)
   end
 end

data/lib/everyday-cli-utils/maputil.rb

@@ -1,48 +1,47 @@
+require_relative 'safe/maputil'
+
 module Enumerable
   def removefalse
-    select { |i| i }
+    EverydayCliUtils::MapUtil.removefalse(self)
   end
 
   def filtermap(&block)
-    map(&block).removefalse
+    EverydayCliUtils::MapUtil.filtermap(self, &block)
   end
 
   def sum
-    reduce(:+)
+    EverydayCliUtils::MapUtil.sum(self)
   end
 
   def prod
-    reduce(:*)
+    EverydayCliUtils::MapUtil.prod(self)
   end
 
   def average
-    sum.to_f / count.to_f
+    EverydayCliUtils::MapUtil.average(self)
   end
 
   def std_dev
-    avg = average
-    cnt = count.to_f
-    su  = summap { |v| (v.to_f - avg.to_f) ** 2 }
-    Math.sqrt(su / cnt)
+    EverydayCliUtils::MapUtil.std_dev(self)
   end
 
   def floats
-    map(&:to_f)
+    EverydayCliUtils::MapUtil.floats(self)
   end
 
   def summap(&block)
-    map(&block).sum
+    EverydayCliUtils::MapUtil.summap(self, &block)
   end
 
   def productmap(&block)
-    map(&block).prod
+    EverydayCliUtils::MapUtil.productmap(self, &block)
   end
 
   def chompall
-    map(&:chomp)
+    EverydayCliUtils::MapUtil.chompall(self)
   end
 
   def join(join_str)
-    map(&:to_s).reduce { |a, b| a << join_str << b }
+    EverydayCliUtils::MapUtil.join(self, join_str)
   end
 end

data/lib/everyday-cli-utils/safe/format.rb

@@ -0,0 +1,107 @@
+module EverydayCliUtils
+  module Format
+    def self.build_format_hash(first_chr)
+      {
+          :black  => "#{first_chr}0",
+          :red    => "#{first_chr}1",
+          :green  => "#{first_chr}2",
+          :yellow => "#{first_chr}3",
+          :blue   => "#{first_chr}4",
+          :purple => "#{first_chr}5",
+          :cyan   => "#{first_chr}6",
+          :white  => "#{first_chr}7",
+          :none   => nil,
+      }
+    end
+
+    FORMAT_TO_CODE   = {
+        :bold      => '1',
+        :underline => '4',
+    }
+    FG_COLOR_TO_CODE = build_format_hash('3')
+    BG_COLOR_TO_CODE = build_format_hash('4')
+
+    def self::format(text, format_code)
+      (format_code.nil? || format_code == '') ? text : "\e[#{format_code}m#{text}\e[0m"
+    end
+
+    def self::build_string(bold, underline, fgcolor, bgcolor)
+      str      = ''
+      hit      = false
+      hit, str = handle_bold(bold, hit, str)
+      hit, str = handle_underline(hit, str, underline)
+      hit, str = handle_fg_color(fgcolor, hit, str)
+      handle_bg_color(bgcolor, hit, str)
+    end
+
+    def self.handle_bold(bold, hit, str)
+      if bold
+        hit = true
+        str = FORMAT_TO_CODE[:bold]
+      end
+      return hit, str
+    end
+
+    def self.handle_underline(hit, str, underline)
+      if underline
+        str += ';' if hit
+        hit = true
+        str += FORMAT_TO_CODE[:underline]
+      end
+      return hit, str
+    end
+
+    def self.handle_fg_color(fgcolor, hit, str)
+      unless fgcolor.nil? || FG_COLOR_TO_CODE[fgcolor].nil?
+        str += ';' if hit
+        hit = true
+        str += FG_COLOR_TO_CODE[fgcolor]
+      end
+      return hit, str
+    end
+
+    def self.handle_bg_color(bgcolor, hit, str)
+      unless bgcolor.nil? || BG_COLOR_TO_CODE[bgcolor].nil?
+        str += ';' if hit
+        str += BG_COLOR_TO_CODE[bgcolor]
+      end
+      str
+    end
+
+    def self::parse_format(str)
+      parts     = str.split(';')
+      bold      = false
+      underline = false
+      fgcolor   = :none
+      bgcolor   = :none
+      parts.each { |v|
+        if v == FORMAT_TO_CODE[:bold]
+          bold = true
+        elsif v == FORMAT_TO_CODE[:underline]
+          underline = true
+        elsif v[0] == '3'
+          fgcolor = FG_COLOR_TO_CODE.invert[v]
+        elsif v[0] == '4'
+          bgcolor = BG_COLOR_TO_CODE.invert[v]
+        end
+      }
+      return bold, underline, fgcolor, bgcolor
+    end
+
+    def self::colorize(text, fgcolor = nil, bgcolor = nil)
+      self::format(text, self::build_string(false, false, fgcolor, bgcolor))
+    end
+
+    def self::bold(text, fgcolor = nil, bgcolor = nil)
+      self::format(text, self::build_string(true, false, fgcolor, bgcolor))
+    end
+
+    def self::underline(text, fgcolor = nil, bgcolor = nil)
+      self::format(text, self::build_string(false, true, fgcolor, bgcolor))
+    end
+
+    def self::boldunderline(text, fgcolor = nil, bgcolor = nil)
+      self::format(text, self::build_string(true, true, fgcolor, bgcolor))
+    end
+  end
+end

data/lib/everyday-cli-utils/safe/histogram.rb

@@ -0,0 +1,39 @@
+module EverydayCliUtils
+  class Histogram
+    def self.setup(collection, height, width)
+      mi     = collection.min
+      ma     = collection.max
+      diff   = ma - mi
+      step   = diff.to_f / (width.to_f - 1)
+      counts = Array.new(width, 0)
+      collection.each { |v| counts[((v - mi).to_f / step.to_f).floor] += 1 }
+      max_y = counts.max
+      lines = Array.new(height) { ' ' * width }
+      return counts, lines, max_y, mi, step
+    end
+
+    def self.add_graph(counts, height, lines, max_y, width)
+      (0...width).each { |i|
+        h = ((counts[i].to_f / max_y.to_f) * height.to_f).round
+        ((height - h)...height).each { |j|
+          lines[j][i] = '#'
+        }
+        if h == 0 && counts[i] > 0
+          lines[height - 1][i] = '_'
+        end
+      }
+    end
+
+    def self.add_averages(height, ks, lines, mi, step, width)
+      lines[height] = ' ' * width
+      ks.each { |v| lines[height][((v - mi) / step).to_i] = '|' }
+    end
+
+    def self.histogram(collection, ks = nil, width = 100, height = 50)
+      counts, lines, max_y, mi, step = setup(collection, height, width)
+      add_graph(counts, height, lines, max_y, width)
+      add_averages(height, ks, lines, mi, step, width) unless ks.nil?
+      lines
+    end
+  end
+end

data/lib/everyday-cli-utils/safe/kmeans.rb

@@ -0,0 +1,152 @@
+require_relative 'maputil'
+
+module EverydayCliUtils
+  module Kmeans
+    def self.normal(x, avg, std)
+      exp = -(((x - avg) / std) ** 2.0) / 2.0
+      ((Math.exp(exp) / (std * Math.sqrt(2.0 * Math::PI))))
+    end
+
+    def self.f_test(clusters, means, cnt, avg)
+      cnt2 = clusters.count { |i| !i.empty? }
+      ev   = f_test_ev(avg, clusters, cnt2, means)
+      uv   = f_test_uv(clusters, cnt, cnt2, means)
+      (ev / uv)
+    end
+
+    def self.f_test_ev(avg, clusters, cnt2, means)
+      ev = 0.0
+      (0...means.count).each { |i| ev += clusters[i].empty? ? 0.0 : clusters[i].count * ((means[i] - avg) ** 2.0) }
+      ev / (cnt2 - 1.0)
+    end
+
+    def self.f_test_uv(clusters, cnt, cnt2, means)
+      uv = 0.0
+      (0...means.count).each { |i|
+        unless clusters[i].empty?
+          (0...clusters[i].count).each { |j|
+            uv += (clusters[i][j] - means[i]) * (clusters[i][j] - means[i])
+          }
+        end
+      }
+      uv / (cnt - cnt2)
+    end
+
+    def self.f_test2(clusters, means, cnt)
+      uv   = 0.0
+      cnt2 = clusters.count { |i| !i.empty? }
+      (0...means.count).each { |i| uv += f_test2_calc(clusters, i, means, uv) unless clusters[i].empty? }
+      (uv / (cnt - cnt2))
+    end
+
+    def self.f_test2_calc(clusters, i, means, uv)
+      tmp = 0.0
+      (0...clusters[i].count).each { |j|
+        tmp += (clusters[i][j] - means[i]) ** 2.0
+      }
+      tmp /= clusters[i].count
+      Math.sqrt(tmp)
+    end
+
+    def self.nmeans_setup_1(collection)
+      su  = EverydayCliUtils::MapUtil.sum(collection)
+      cnt = collection.count
+      avg = su / cnt
+      ks1 = kmeans(collection, 1)
+      return avg, cnt, ks1
+    end
+
+    def self.nmeans_setup_2(collection, avg, cnt, ks1)
+      cso = get_clusters(collection, ks1)
+      ft1 = f_test2(cso, ks1, cnt)
+      ks  = kmeans(collection, 2)
+      cs  = get_clusters(collection, ks)
+      ft  = f_test(cs, ks, cnt, avg)
+      ft2 = f_test2(cs, ks, cnt)
+      return ft, ft1, ft2, ks
+    end
+
+    def self.run_nmean(collection, avg, cnt, ft, ft2, k, ks)
+      kso  = ks
+      fto  = ft
+      fto2 = ft2
+      ks   = kmeans(collection, k)
+      cs   = get_clusters(collection, ks)
+      ft   = f_test(cs, ks, cnt, avg)
+      ft2  = f_test2(cs, ks, cnt)
+      return ft, ft2, fto, fto2, ks, kso
+    end
+
+    def self.run_nmeans(avg, cnt, collection, ft, ft1, ft2, ks, ks1, max_k, threshold)
+      (3..[max_k, cnt].min).each { |k|
+        ft, ft2, fto, fto2, ks, kso = run_nmean(collection, avg, cnt, ft, ft2, k, ks)
+        return kso if ((ft - fto) / fto) < threshold && fto2 < ft1
+      }
+      ft2 >= ft1 ? ks1 : ks
+    end
+
+    def self.run_kmean(collection, ks)
+      kso      = ks
+      clusters = get_clusters(collection, kso)
+      ks       = []
+      clusters.each_with_index { |val, key| ks[key] = (val.count <= 0) ? kso[key] : (val.sum / val.count) }
+      ks.sort
+      return kso, ks
+    end
+
+    def self.get_clusters(collection, means)
+      clusters = Array.new(means.count) { Array.new }
+      collection.each { |item|
+        cluster  = false
+        distance = false
+        (0...means.count).each { |i|
+          diff = (means[i] - item).abs
+          if distance == false || diff < distance
+            cluster  = i
+            distance = diff
+          end
+        }
+        clusters[cluster] << item
+      }
+      clusters
+    end
+
+    def self.kmeans(collection, k)
+      mi   = collection.min
+      ma   = collection.max
+      diff = ma - mi
+      ks   = []
+      (1..k).each { |i| ks[i - 1] = mi + (i * (diff / (k + 1.0))) }
+      kso = false
+      while ks != kso
+        kso, ks = run_kmean(collection, ks)
+      end
+      ks
+    end
+
+    def self.nmeans(collection, max_k = 10, threshold = 0.05)
+      collection    = EverydayCliUtils::MapUtil.floats(collection)
+      avg, cnt, ks1 = nmeans_setup_1(collection)
+      return ks1 if cnt == 1
+      ft, ft1, ft2, ks = nmeans_setup_2(collection, avg, cnt, ks1)
+      run_nmeans(avg, cnt, collection, ft, ft1, ft2, ks, ks1, max_k, threshold)
+    end
+
+    def self.find_outliers(avg, cs, i, sensitivity)
+      csi = cs[i]
+      std = EverydayCliUtils::MapUtil.std_dev(csi)
+      cnt = csi.count
+      csi.select { |c| (normal(c, avg, std) * cnt) < sensitivity }
+    end
+
+    def self.outliers(collection, sensitivity = 0.5, k = nil)
+      ks = k.nil? ? nmeans(collection) : kmeans(collection, k)
+      cs = get_clusters(collection, ks)
+
+      outliers = []
+
+      ks.each_with_index { |avg, i| outliers += find_outliers(avg, cs, i, sensitivity) }
+      outliers
+    end
+  end
+end

data/lib/everyday-cli-utils/safe/maputil.rb

@@ -0,0 +1,50 @@
+module EverydayCliUtils
+  module MapUtil
+    def self.removefalse(collection)
+      collection.select { |i| i }
+    end
+
+    def self.filtermap(collection, &block)
+      removefalse(collection.map(&block))
+    end
+
+    def self.sum(collection)
+      collection.reduce(:+)
+    end
+
+    def self.prod(collection)
+      collection.reduce(:*)
+    end
+
+    def self.average(collection)
+      sum(collection).to_f / collection.count.to_f
+    end
+
+    def self.std_dev(collection)
+      avg = average(collection)
+      cnt = collection.count.to_f
+      su  = summap(collection) { |v| (v.to_f - avg.to_f) ** 2 }
+      Math.sqrt(su / cnt)
+    end
+
+    def self.floats(collection)
+      collection.map(&:to_f)
+    end
+
+    def self.summap(collection, &block)
+      sum(collection.map(&block))
+    end
+
+    def self.productmap(collection, &block)
+      prod(collection.map(&block))
+    end
+
+    def self.chompall(collection)
+      collection.map(&:chomp)
+    end
+
+    def self.join(collection, join_str)
+      collection.map(&:to_s).reduce { |a, b| a << join_str << b }
+    end
+  end
+end

data/lib/everyday-cli-utils/version.rb

@@ -1,3 +1,3 @@
 module EverydayCliUtils
-  VERSION = '0.0.2'
+  VERSION = '0.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: everyday-cli-utils
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Eric Henderson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-23 00:00:00.000000000 Z
+date: 2014-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -120,6 +120,10 @@ files:
 - lib/everyday-cli-utils/maputil.rb
 - lib/everyday-cli-utils/mycurses.rb
 - lib/everyday-cli-utils/option.rb
+- lib/everyday-cli-utils/safe/format.rb
+- lib/everyday-cli-utils/safe/histogram.rb
+- lib/everyday-cli-utils/safe/kmeans.rb
+- lib/everyday-cli-utils/safe/maputil.rb
 - lib/everyday-cli-utils/version.rb
 - spec/everyday-cli-utils/format_spec.rb
 - spec/everyday-cli-utils/kmeans_spec.rb