homeq 1.1.4

data/lib/homeq/base/histogram.rb

@@ -0,0 +1,141 @@
+#!/usr/bin/ruby
+
+#############################################################################
+#
+# $Id: homeq.rb 8 2008-08-27 20:15:22Z colin $
+#
+# This code is distributed freely in the sense of GNU GPL.
+# K.Kodama 2005-03-01
+# 
+#----------------------------------------------------------------------------
+#
+#      Copyright (C) 2008 by Colin Steele. All Rights Reserved.
+#                        colin@colinsteele.org
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+#############################################################################
+
+module HomeQ
+  
+  class Histogram
+    attr :min;
+    attr :max;
+    attr :w; # class width
+    attr :f; # array of frequency
+
+    attr :num;
+    attr :s1;
+    attr :s2;
+    attr :s3;
+    attr :s4;
+
+    def h_class(x)
+      ((x-@min)/@w).truncate
+    end;
+    def bar(x,unit=1)
+      n = (x.to_f.nan? ? 0 : x.to_f / unit).ceil
+      ("----+" * (n/5+1))[0,n]
+    end;
+
+    def initialize(min,max,width)
+      @min=min; @max=max; @w=width; @f=Array::new(h_class(@max)+1,0)
+      @num=0; @s1=0.0; @s2=0.0; @s3=0.0; @s4=0.0;
+    end
+    
+    def push(x)
+      @num+=1; @s1+=x; @s2+=(x**2); @s3+=(x**3); @s4+=(x**4); 
+      @f[h_class([[@min,x].max, @max].min)]+=1
+    end
+    alias_method :<<, :push
+
+    # statistics
+    def size
+      @num # s=0; @f.each{|n| s+=n}; return s
+    end
+    
+    def sum
+      @s1
+    end
+    
+    def avg
+      @s1/@num # average or arithmetic mean
+    end
+    
+    def variance
+      (@s2/@num)-(@s1/@num)**2 # v=E((x-m)^2)=E(x^2)-m^2  where m=E(X).
+    end
+    
+    def sd
+      return 0 if variance.nan?
+      Math::sqrt(variance) # standard deviation.
+    end
+    
+    def cv
+      sd/avg # coefficient of variation
+    end
+    
+    def skewness
+      # skewness E((x-m)^3)/s^3=(E(x^3)-3*m*E(x^2) + 2 m ^3)/s^3
+      m=avg; s=sd; ((@s3-3*m*@s2)/@num+2*m*m*m)/(s*s*s)
+    end
+    
+    def kurtosis
+      # kurtosis E((x-m)^4)/s^4=(E(x^4)-4mE(x^3)+6m^2E(x^2)-3m^4)/s^4
+      m=avg; v=variance; ((@s4-4*m*@s3+6*m*m*@s2)/@num-3*m**4)/(v*v)
+    end
+
+    def to_s(unit=1)
+      form=sprintf("%%%d.1f-.:%%s %%2.1f%%%% %%d\n", @max.to_s.size + 2)
+      s = ''
+      for i in 0..h_class(@max)
+        percentage = @f[i].to_f / size * 100.0
+        s << sprintf(form,
+                     @min+i*@w,
+                     bar(percentage / 1.8, unit),
+                     percentage.nan? ? 0 : percentage,
+                     @f[i])
+      end
+      s
+    end
+    
+    def report(unit=1)
+      str = to_s(unit)
+      str <<
+        "number: %d, average: %4.2f, std dev: %4.2f\n" % [size, avg, sd]
+    end
+
+  end # Histogram
+
+end # HomeQ
+
+if $0 == __FILE__
+
+  require 'test/unit/testsuite'
+  require 'test/unit'
+
+  class TC_MyTest < Test::Unit::TestCase
+    def test_simple
+      
+      # Example.
+      hist=HomeQ::Histogram.new(0,10,0.5) # lower bound/upper bound/class width
+      hist.push(51) # push data
+      hist.push(62)
+      hist.push(31)
+      1.upto(9) do
+        hist << rand
+      end
+      puts hist.report # print histogram
+    end
+    
+  end
+  
+end

data/lib/homeq/base/logger.rb

@@ -0,0 +1,185 @@
+#############################################################################
+#
+# $Id: logger.rb 48 2008-11-19 05:11:59Z colin $
+#
+# Author:: Colin Steele (colin@colinsteele.org)
+# Homepage::  
+# 
+# TODO: info 
+#
+#----------------------------------------------------------------------------
+#
+#      Copyright (C) 2008 by Colin Steele. All Rights Reserved.
+#                        colin@colinsteele.org
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+#############################################################################
+
+require 'singleton'
+
+module HomeQ
+
+  module Base
+
+    module Logging
+
+      module HomeQ::Base::Commando::InstanceMethods
+        config_accessor :log_id
+        def log_level(*args)
+          HomeQ::Base::Logging::Logger.instance.log_level(*args)
+        end
+        def log_file(*args)
+          HomeQ::Base::Logging::Logger.instance.log_file(*args)
+        end
+        def syslog
+          HomeQ::Base::Logging::Logger.instance.syslog
+        end
+        document_command(:syslog, "Send logging through syslog")
+        document_command(:log_file, "Log to the specified file")
+        document_command(:log_level,
+                         "Set log level (DEBUG < INFO < WARN < ERROR < FATAL)")
+      end
+      
+      def logger
+        Logger.instance.logger
+      end
+
+      class Logger
+
+        PAT = "%d %l %c %m"
+
+        include Singleton
+        include Base::Configuration
+
+        begin
+
+          require 'log4r'
+          require 'log4r/configurator'
+          
+          attr :logger
+
+          def initialize
+            # create a logger that logs to stdout
+            @id = config.log_id || File.basename($0)
+
+            # DEBUG < INFO < WARN < ERROR < FATAL
+            levels = [
+              :DEBUG4, :DEBUG3, :DEBUG2, :DEBUG1, :DEBUG,
+              :INFO, :WARN, :ERROR, :FATAL
+            ]
+            Log4r::Configurator.custom_levels(*levels)
+            @logger = Log4r::Logger.new(@id)
+            @logger.level = Log4r.const_get("INFO")
+          end
+
+          def stdout
+            o = Log4r::Outputter.stdout
+            o.formatter = Log4r::PatternFormatter.new(:pattern => PAT)
+            @logger.outputters << o
+          end
+
+          def syslog
+            with_warnings_suppressed do            
+              levels = %w(DEBUG INFO WARN ERROR FATAL)
+              Log4r.class_eval {
+                remove_const('OFF')
+                Log4r::LNAMES.slice!(0..-1)
+                require 'log4r/outputter/syslogoutputter'
+              }
+            end
+            @id = config.log_id || File.basename($0)
+            logger = Log4r::Logger.new(@id)
+            o = Log4r::SyslogOutputter.new(@id)
+            o.formatter = Log4r::PatternFormatter.new(:pattern => PAT)
+            logger.outputters = o
+            @logger.info {
+              "Logging to syslog with USER facility."
+            }
+            logger.level = Log4r.const_get("INFO")
+            @logger = logger
+          end
+
+          def log_file(*args)
+            hash = {
+              :filename => args[0],
+              :trunc => false
+            }
+            o = Log4r::FileOutputter.new(@id, hash)
+            o.formatter = Log4r::PatternFormatter.new(:pattern => PAT)
+            @logger.outputters << o
+            @logger.info {
+              "Logging to #{args[0]}."
+            }
+          end
+
+          def log_level(*args)
+            return @level if args.empty?
+            if args[0].is_a?(String)
+              level = Log4r.const_get(args[0].upcase)
+            else
+              level = Log4r.const_get("INFO") - args[0].to_i
+              level = [level,0].max
+              level = [level,10].min
+            end
+            old_level = @logger.level
+            @logger.level = level
+            if old_level != level
+              @logger.info {
+                "Log level is #{Log4r::LNAMES[@logger.level]}"
+              }
+            end
+            Log4r::LNAMES[@logger.level]
+          end
+
+          def logger
+            @logger
+          end
+
+          # rescue LoadError
+          rescue => e
+
+          def debug(*args)
+            if block_given?
+              STDERR.puts yield
+            else
+              STDERR.puts args.join("\n")
+            end
+          end
+
+          %w(info warn error fatal debug1 debug2 debug3 debug4).each { |x|
+            module_eval("alias_method :#{x}, :debug")
+          }
+
+          def logger
+            self
+          end
+
+        end # begin block
+
+        def with_warnings_suppressed
+          saved_verbosity = $-v
+          $-v = nil
+          yield
+        ensure
+          $-v = saved_verbosity
+        end
+
+      end # Logger
+
+    end # Logging
+
+  end # Base
+  
+end # HomeQ
+  
+
+

data/lib/homeq/base/ohash.rb

@@ -0,0 +1,297 @@
+#!/usr/bin/ruby
+
+#############################################################################
+#
+# $Id: homeq.rb 8 2008-08-27 20:15:22Z colin $
+#
+# Author:: Colin Steele (colin@colinsteele.org)
+# Homepage::  
+# 
+# TODO: info 
+#
+#----------------------------------------------------------------------------
+#
+#      Copyright (C) 2008 by Colin Steele. All Rights Reserved.
+#                        colin@colinsteele.org
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+#############################################################################
+
+module HomeQ
+  
+  class OHash
+
+    include Enumerable
+    
+    def initialize
+      @keys = {}
+      @queue = []
+    end
+    def insert(key, value)
+      if @keys.member?(key)
+        raise ArgumentException.new("Duplicate key")
+      end
+      @queue << key
+      @keys[key] = value
+    end
+    alias_method :push, :insert
+    def delete(key)
+      @queue.delete(key)
+      @keys.delete(key)
+    end
+    def [](key)
+      @keys[key]
+    end
+    def []=(key, val)
+      if @keys.member?(key)
+        @keys[key] = val
+      else
+        insert(key, val)
+      end
+    end
+    def each
+      @queue.each {|k|
+        yield k, @keys[k]
+      }
+    end
+    def keys
+      @keys.keys
+    end
+    def length
+      @keys.length
+    end
+    alias_method :size, :length
+    def member?(key)
+      @keys.member?(key)
+    end
+    alias_method :has_key?, :member?
+    def pop
+      k = @queue.slice!(-1)
+      [k,@keys.delete(k)]
+    end
+    def unshift(k,v)
+      # Yes, could have called insert here and then manipulated @queue
+      # after, that would be more DRY.  But this is *much* faster.
+      if @keys.member?(k)
+        raise ArgumentException.new("Duplicate key")
+      end
+      @queue.unshift(k)
+      @keys[k] = v
+      [k,v]
+    end
+    def shift
+      k = @queue.shift
+      [k,@keys.delete(k)]
+    end
+    def first
+      [@queue.first, self[@queue.first]]
+    end
+    def last
+      [@queue.last, self[@queue.last]]
+    end
+  end
+
+end  # module HomeQ
+  
+if $0 == __FILE__
+
+  require 'benchmark'
+  require 'rubygems'
+  require 'facets/dictionary'
+
+  array = (1..1000000).map { rand }
+  d = nil
+  h = nil
+  oh = nil
+  
+  if nil
+    Benchmark.bmbm do |x|
+      len = 100000
+      x.report("unshift") {
+        a = []
+        0.upto(len) {
+          a.push(rand)
+        }
+      }
+      x.report("insert") {
+        a = []
+        0.upto(len) {
+          a.insert(0,rand)
+        }
+      }
+    end
+    exit
+  end
+
+  puts "\nINSERT"
+  Benchmark.bmbm do |x|
+    x.report("hash") {
+      h = Hash.new
+      array.each_with_index {|v,i|
+        h[i] = v
+      }
+    }
+    x.report("facets") {
+      d = Dictionary.new
+      array.each_with_index {|v,i|
+        d[i] = v
+      }
+    }
+    x.report("ohash")  {
+      oh = HomeQ::OHash.new
+      array.each_with_index {|v,i|
+        oh[i] = v
+      }
+    }
+  end
+
+  puts "\nFIND"
+  Benchmark.bmbm do |x|
+    len = array.length
+    x.report("hash") {
+      array.each {
+        ind = rand(len)
+        h[ind]
+      }
+    }
+    x.report("facets") {
+      array.each {
+        ind = rand(len)
+        d[ind]
+      }
+    }
+    x.report("ohash")  {
+      array.each {
+        ind = rand(len)
+        oh[ind]
+      }
+    }
+  end
+
+  puts "\nPUSH"
+  Benchmark.bmbm do |x|
+    x.report("hash") {
+      h = Hash.new
+      array.each_with_index {|v,i|
+        h[i] = v
+      }
+    }
+    x.report("facets") {
+      d = Dictionary.new
+      array.each_with_index {|v,i|
+        d.push(i,v)
+      }
+    }
+    x.report("ohash")  {
+      oh = HomeQ::OHash.new
+      array.each_with_index {|v,i|
+        oh.push(i,v)
+      }
+    }
+  end
+  
+  puts "\nUNSHIFT"
+  Benchmark.bmbm do |x|
+    x.report("hash") {
+      h = Hash.new
+      array.each_with_index {|v,i|
+        break if i > 10000
+        h[i] = v
+      }
+    }
+    x.report("facets") {
+      d = Dictionary.new
+      array.each_with_index {|v,i|
+        break if i > 10000
+        d.unshift(i,v)
+      }
+    }
+    x.report("ohash")  {
+      oh = HomeQ::OHash.new
+      array.each_with_index {|v,i|
+        break if i > 10000
+        oh.unshift(i,v)
+      }
+    }
+  end
+  
+  puts "\nPOP"
+  Benchmark.bmbm do |x|
+    x.report("facets pop x 10") {
+      0.upto(10) { |i|
+        d.pop
+      }
+    }
+    x.report("ohash pop x 10000")  {
+      0.upto(10000) {
+        oh.pop
+      }
+    }
+  end
+
+  puts "\nSHIFT"
+  Benchmark.bmbm do |x|
+    x.report("facets shift x 10") {
+      0.upto(10) { |i|
+        d.shift
+      }
+    }
+    x.report("ohash shift x 10000")  {
+      0.upto(10000) {
+        oh.shift
+      }
+    }
+  end
+
+  require 'test/unit/testsuite'
+  require 'test/unit'
+
+  class TC_MyTest < Test::Unit::TestCase
+    def test_simple
+      h = HomeQ::OHash.new
+      h.push(99,100)
+      assert_equal([99,100], h.pop)
+      assert_equal(0, h.length)
+      assert_equal([nil,nil], h.first)
+    end
+    
+    def test_more
+      h = HomeQ::OHash.new
+      100.upto(199) do |i|
+        h.push(i,i-99)
+      end
+      assert_equal([199,100], h.pop)
+      assert_equal(99, h.length)
+      assert_equal([100,1], h.first)
+      assert_equal([100,1], h.shift)
+      assert_equal([101,2], h.first)
+      assert_equal([:x,:y], h.unshift(:x, :y))
+      assert_equal([:x,:y], h.first)
+      assert_equal([:x,:y], h.shift)
+      assert_equal(98, h.length)
+      assert_equal([101,2], h.first)
+      assert_equal([198,99], h.last)
+      assert_equal(51, h.delete(150))
+      assert_equal(97, h.length)
+      assert_equal(:x, h[150] = :x)
+      assert_equal(:x, h[150])
+      assert_equal(:y, h[150] = :y)
+      assert_equal(:y, h[150])
+      assert_equal(98, h.length)
+      assert_equal(true, h.member?(150))
+      assert_equal(false, h.member?(:not_a_member))
+      assert_equal(true, h.keys.include?(198))
+      assert_equal(false, h.keys.include?(199))
+      assert_equal(false, h.member?(199))
+    end
+  end
+end