darkext 0.12.0

data/lib/darkext/sitemap_generator.rb

@@ -0,0 +1,90 @@
+require 'hpricot'
+require 'open-uri'
+require 'builder'
+require 'darkext/hash'
+
+module Darkext
+  class Darkext::SitemapBuilder
+    FORUM_CLASS_DEFAULT = 'forumtitle'
+    TOPIC_CLASS_DEFAULT = 'topictitle'
+    FORUM_PRIORITY_DEFAULT = 0.8
+    TOPIC_PRIORITY_DEFAULT = 0.5
+    PAGE_PRIORITY_DEFAULT = 0.1
+    FORUM_CHANGE_FREQ_DEFAULT = 'daily'
+    TOPIC_CHANGE_FREQ_DEFAULT = 'hourly'
+    PAGE_CHANGE_FREQ_DEFAULT = 'monthly'
+
+    def initialize(opts={})
+      defaults = {
+        :forum => {
+          :class => FORUM_CLASS_DEFAULT,
+          :priority => FORUM_PRIORITY_DEFAULT,
+          :change_freq => FORUM_CHANGE_FREQ_DEFAULT
+        },
+        :topic => {
+          :class => TOPIC_CLASS_DEFAULT,
+          :priority => TOPIC_PRIORITY_DEFAULT,
+          :change_freq => TOPIC_CHANGE_FREQ_DEFAULT
+        },
+        :page => {
+          :priority => PAGE_PRIORITY_DEFAULT,
+          :change_freq => PAGE_CHANGE_FREQ_DEFAULT
+        }
+      }
+      defaults.deep_merge!(opts)
+
+      @options = defaults
+
+      @forums = Array.new
+      @topics = Array.new
+      @pages = Array.new
+    end
+
+    def index(url, target = $stdout)
+      @pages << url
+
+      root = Hpricot(open(url))
+      (root/"a.#{@options.nested_find(:forum,:class)}").each do |link|
+        index_forum(link.attributes['href'].to_s)
+      end
+
+      xml = Builder::XmlMarkup.new(:target => $stdout, :indent => 1)
+      xml.instruct!
+      xml.urlset "xmlns" => "http://www.sitemaps.org/schemas/sitemap/0.9" do
+        @pages.each do |page|
+          xml.url do
+            xml.loc(page)
+            xml.changefreq(@options.nested_find(:page,:change_freq))
+            xml.priority(@options.nested_find(:page,:priority))
+          end
+        end
+        @forums.each do |forum|
+          xml.url do
+            xml.loc(forum)
+            xml.changefreq(@options.nested_find(:forum,:change_freq))
+            xml.priority(@options.nested_find(:forum,:priority))
+          end
+        end
+        @topics.each do |topic|
+          xml.url do
+            xml.loc(topic)
+            xml.changefreq(@options.nested_find(:topic,:change_freq))
+            xml.priority(@options.nested_find(:topic,:priority))
+          end
+        end
+      end
+    end
+
+    private
+    def index_forum(href)
+      root = Hpricot(open(href))
+      (root/"a.#{@options.nested_find(:forum,:class)}").each do |link|
+        index_forum(link.attributes['href'].to_s)
+      end
+      (root/"a.#{@options.nested_find(:topic,:class)}").each do |link|
+        @topics << link.attributes['href'].to_s
+      end
+      @forums << href
+    end
+  end
+end

data/lib/darkext/statistics.rb

@@ -0,0 +1,197 @@
+require 'mathn'
+
+require 'darkext/array'
+require 'darkext/numeric'
+require 'darkext/symbol'
+
+class Array
+  # Finds the mean of the array
+  def mean
+    raise ArgumentError.new('Array size must be > 0') if self.size.zero?
+    self.sum / self.size.to_f
+  end
+  alias :average :mean
+  alias :ave :mean
+
+  def harmonic_mean
+    raise ArgumentError.new('Array size must be > 0') if self.size.zero?
+    self.size.to_f / self.map { |i| 1 / i.to_f }.sum
+  end
+  alias :h_mean :harmonic_mean
+
+  def geometric_mean
+    raise ArgumentError.new('Array size must be > 0') if self.size.zero?
+    self.product.root(self.size)
+  end
+  alias :g_mean :geometric_mean
+
+  # Finds the median of the array
+  def median
+    raise ArgumentError.new('Array size must be > 0') if self.size.zero?
+    case self.size % 2
+    when 0
+      return self.sort[(self.size / 2) - 1, 2].mean
+    when 1
+      return self.sort[self.size / 2]
+    end
+  end
+
+  # Generates a histogram hash for the array
+  def histogram
+    self.sort.inject({}) do |a,x|
+      a[x] = a[x].to_i + 1
+      a
+    end
+  end
+
+  # Finds the mode of the array
+  def mode
+    raise ArgumentError.new('Array size must be > 0') if self.size.zero?
+    map = self.histogram
+    max = map.values.max
+    map.keys.select { |x| map[x] == max }
+  end
+
+  # Variance
+  def variance
+    raise ArgumentError.new('Array size must be > 0') if self.size.zero?
+    self.sum_of_squares.to_f / (self.size).to_f
+  end
+
+  # Standard deviation
+  def standard_deviation
+    raise ArgumentError.new('Array size must be > 0') if self.size.zero?
+    self.variance.abs.sqrt
+  end
+  alias :stddev :standard_deviation
+
+  # Randomly samples n elements
+  def sample(n = 1)
+    (1..n).collect { self[rand(self.size)] }
+  end
+
+  # Generates a confidence interval
+  def ci(opts = { })
+    raise ArgumentError.new('Array size must be > 0') if self.size.zero?
+    opts = { :percent => 0.95, :rho => 1, :type => :center }.merge(opts)
+    percent = opts[:percent]
+    rho = opts[:rho]
+    m = self.mean
+    ret = Array.new
+    div = (opts[:type] == :center ? 2 : 1)
+    i = ((Darkext::Statistics::zscore((1 - percent) / div) * rho) /
+         self.size.sqrt).abs
+    case opts[:type]
+    when :center
+      ret << m - i
+      ret << m + i
+    when :upper
+      ret << m + i
+    when :lower
+      ret << m - i
+    end
+    return ret
+  end
+
+  # Standardizes the array
+  def standardize
+    self.clone.standardize!
+  end
+
+  # Destructive standardize
+  def standardize!
+    m = self.mean.to_f
+    rho = self.standard_deviation.to_f
+    self.map! { |v| (v.to_f - m) / rho }
+  end
+
+  def sum_of_squares
+    raise ArgumentError.new('Array size must be > 0') if self.size.zero?
+    m = self.mean
+    self.map { |v| v - m }.squares.sum
+  end
+end
+
+module Darkext
+  module Darkext::Statistics
+    # Finds the probability of a z-score
+    def self.prob(z)
+      p = Math::erf(z.abs/2.sqrt) / 2
+      return 0.5 + p if 0 < z
+      return 0.5 - p
+    end
+
+    # Finds the zscore of a probability
+    def self.zscore(p, epsilon = 0.00000000000001)
+      return -1 if (1 < p || 0 > p)
+      minz, maxz = -6, 6
+      zscore = 0.5
+      prob = 0
+      while (maxz - minz) > epsilon
+        prob = prob(zscore)
+        prob > p ? maxz = zscore : minz = zscore
+        zscore = (maxz + minz) * 0.5
+      end
+      return zscore
+    end
+
+    # Finds a two tail p-val for a high/low array
+    # can't remember how to use this
+=begin
+    def self.p_val(r, n = 30, rho = 1, mu = r.mean)
+      probs = r.map do |x|
+        (x - mu) / (rho / n.sqrt)
+      end.map do |x|
+        Statistics::prob(x)
+      end
+      return 1 - (probs[1] - probs[0])
+    end
+=end
+
+    module Darkext::Statistics::Regression
+      # Do a least squares linear regression on the two sets of x's and y's
+      # Returns a hash containing many relevant values
+      # * n (:n)
+      # * B_1 (:b_1)
+      # * B_0 (:b_0)
+      # * predicted values (:predicted)
+      # * residuals (:residuals)
+      # * SSE (:ss_e)
+      # * SST (:ss_t)
+      # * R^2 (:r_2)
+      # * R (:r)
+      # * unbiased estimator (:estimator)
+      # * the equation as a lambda (:equation)
+      # Raises an argument error if the arguments are not the same size or either is zero
+      def self.least_squares(xs,ys)
+        raise ArgumentError.new('Arrays must have size > 0') if xs.size.zero? || ys.size.zero?
+        raise ArgumentError.new('Arrays must be of equal size') if xs.size != ys.size
+        n = xs.size
+        b_1 = (xs.zip(ys).map(&:product).sum - ((ys.sum * xs.sum)/n))/(xs.map(&:square).sum - (xs.sum.square/n))
+        b_0 = ys.mean - b_1 * xs.mean
+        equation = lambda { |x| b_0 + b_1 * x }
+        predicted = xs.map(&equation)
+        residuals = ys.zip(predicted).map { |y| y.shift - y.shift }
+        ss_e = residuals.map(&:square).sum
+        ss_t = ys.sum_of_squares
+        estimator = ss_e/(n - 2)
+        r_2 = 1 - (ss_e/ss_t)
+        r = r_2.sqrt
+        reg = {
+          :n => n,
+          :b_1 => b_1,
+          :b_0 => b_0,
+          :predicted => predicted,
+          :residuals => residuals,
+          :ss_e => ss_e,
+          :ss_t => ss_t,
+          :estimator => estimator,
+          :equation => equation,
+          :r_2 => r_2,
+          :r => r
+        }
+        return reg
+      end
+    end
+  end
+end

data/lib/darkext/string.rb

@@ -0,0 +1,63 @@
+require 'darkext/hash'
+
+class String
+  # Parses a string like "1..10" to a Range
+  def to_range
+    case self.count('.')
+    when 2
+      elements = self.split('..')
+      if elements[0] == elements[0].to_i.to_s
+        return Range.new(elements[0].to_i, elements[1].to_i)
+      else
+        return Range.new(elements[0], elements[1])
+      end
+    when 3
+      elements = self.split('...')
+      if elements[0] == elements[0].to_i.to_s
+        return Range.new(elements[0].to_i, elements[1].to_i, true)
+      else
+        return Range.new(elements[0], elements[1], true)
+      end
+    end
+    raise ArgumentError.new('Could not parse range')
+  end
+
+  # Executes the string with system
+  # * :background => true to run command in the background using & (currently only works on *nix systems)
+  # * :capture => true to capture the output. If :capture => true, background is voided
+  def exec(opts = {})
+    opts.with_defaults!(:background => false, :capture => false)
+    return `#{self}` if opts[:capture]
+    return fork { system(self) } if opts[:background]
+    return system(self)
+  end
+
+  # Prints the String using print
+  def print
+    Kernel.print(self)
+  end
+
+  def printn
+    Kernel.print(self + "\n")
+  end
+
+  def true?
+    self.downcase == 'true'
+  end
+
+  def false?
+    self.downcase == 'false'
+  end
+
+  def starts_with?(str)
+    str = str.to_s
+    str == self[0, str.length]
+  end
+
+  def ends_with?(str)
+    str = str.to_s
+    str == self[-str.length, str.length]
+  end
+
+  alias :/ :split
+end

data/lib/darkext/symbol.rb

@@ -0,0 +1,7 @@
+class Symbol
+  # Does exactly what the activesupport version does,
+  # with pretty much the same code.
+  def to_proc
+    Proc.new { |*args| args.shift.__send__(self, *args) }
+  end
+end

data/spec/array_spec.rb

@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Array do
+  before(:each) do
+    @a = (1..5).to_a
+  end
+
+  it 'should respond to all the new methods' do
+    %w(rotate rotate_reverse sum product squares squares! random pick randomize randomize!).each { |method| [1].methods.include?(method).should == true }
+  end
+
+  it 'should not remove or add elements when randomizing' do
+    @a.randomize.size.should == @a.size
+  end
+
+  it 'should rotate back to normal' do
+    b = @a.clone
+    b.rotate(b.size)
+    b.should == @a
+  end
+
+  it 'should rotate reverse back to normal' do
+    b = @a.clone
+    b.rotate_reverse(b.size)
+    b.should == @a
+  end
+
+  it 'should return a Numeric from sum and sum' do
+    @a.sum.should be_a_kind_of(Numeric)
+    @a.product.should be_a_kind_of(Numeric)
+  end
+
+  it 'should return an array of equal size from squares' do
+    squares = @a.squares
+    squares.should be_a_kind_of(Array)
+    squares.size.should == @a.size
+  end
+
+  it 'should destructively collect squares' do
+    b = @a.clone
+    b.squares!.should == @a.squares
+  end
+
+  it 'should pick randomly' do
+    counts = [0,0,0,0,0]
+    count = 1000000
+    count.times do
+      r = @a.random
+      counts[r - 1] += 1
+    end
+    counts.each do |v|
+      (v/count.to_f).should be_close(1/counts.size.to_f,0.001)
+    end
+
+    @a.include?(@a.random).should be_true
+  end
+
+  it 'should return an Array from randomize' do
+    @a.randomize.should be_a_kind_of(Array)
+  end
+
+  it 'should return nil from sum, product and random if size == 0' do
+    %w(sum product random).each do |method|
+      Array.new.send(method.intern).should be_nil
+    end
+  end
+
+  it 'should rotate properly' do
+    @a.rotate
+    @a.should == [2,3,4,5,1]
+    @a.rotate
+    @a.should == [3,4,5,1,2]
+    @a.rotate(@a.size)
+    @a.should == [3,4,5,1,2]
+  end
+
+  it 'should rotate reverse properly' do
+    @a.rotate_reverse
+    @a.should == [5,1,2,3,4]
+    @a.rotate_reverse
+    @a.should == [4,5,1,2,3]
+    @a.rotate_reverse(@a.size)
+    @a.should == [4,5,1,2,3]
+  end
+
+  it 'should sum properly' do
+    @a.sum.should == 15
+    [1].sum.should == 1
+    %w(a b c).sum.should == 'abc'
+    [1.0,0.1,0.01].sum.should == 1.11
+  end
+
+  it 'should do product properly' do
+    @a.product.should == 120
+    [1].product.should == 1
+    ['a',3].product.should == 'aaa'
+  end
+
+  it 'should do squares properly' do
+    @a.squares.should == [1,4,9,16,25]
+    [1].squares.should == [1]
+    @a.squares!
+    @a.should == [1,4,9,16,25]
+  end
+
+  it 'should randomize' do
+    @a.randomize.should_not == @a
+    a = @a.clone
+    @a.randomize!
+    @a.should_not == a
+  end
+end