facets 2.9.2 → 2.9.3

data/src/standard/facets/math/root.rb

@@ -1,8 +0,0 @@
-module Math
-
-  # The +y+ root of +x+.
-  def self.root(x, y)
-    x ** (1.0 / y)
-  end
-
-end

data/src/standard/facets/math/sec.rb

@@ -1,8 +0,0 @@
-module Math
-
-  # Secans of +x+.
-  def self.sec(x)
-    1.0 / cos(x)
-  end
-
-end

data/src/standard/facets/math/sech.rb

@@ -1,8 +0,0 @@
-module Math
-
-  # Secans hyperbolicus of +x+
-  def self.sech(x)
-    1.0 / cosh(x)
-  end
-
-end

data/src/standard/facets/math/sign.rb

@@ -1,9 +0,0 @@
-module Math
-
-  # Sign of +x+.
-  # Returns -1 for negative x, +1 for positive x and zero for x = 0 
-  def self.sign(x)
-    (x > 0.0) ? 1.0 : ((x < 0.0) ? -1.0 : 0.0)
-  end
-
-end

data/src/standard/facets/math/sinc.rb

@@ -1,8 +0,0 @@
-module Math
-
-  # Sinc function of +x+.
-  def self.sinc(x)
-    (x == 0.0) ? 1.0 : sin(x) / x
-  end
-
-end

data/src/standard/facets/math/sqr.rb

@@ -1,8 +0,0 @@
-module Math
-
-  # Square of number.
-  def self.sqr(x)
-    x * x
-  end
-
-end

data/src/standard/facets/math/sqsolve.rb

@@ -1,53 +0,0 @@
-module Math
-
-  # Returns array of real solution of <code>ax**2 + bx + c = d</code>
-  # or <code>nil</code> if no or an infinite number of solutions exist.
-  # If +d+ is missing it is assumed to be 0.
-  #
-  # == Solving second order equations
-  # In order to solve <code>ax**2 + bx + c = d</code> +Extmath.sqsolve+ identifies several cases:
-  # * <code>a == 0:</code>
-  #   The equation to be solved is the linear equation <code>bx + c = d</code>. #sqsolve> delegates the computation to
-  #   #linsolve>. If it results in +nil+, +nil+ is returned (not <code>[nil]</code>!). Otherwise a one-element array
-  #   containing result of #linsolve is returned.
-  # * <code>a != 0:</code>
-  #    The equation to be solved actually is a second order one.
-  #    * <code>c == d</code>
-  #      The equation to be solved is <code>ax**2 + bx = 0</code>. One solution of this equation obviously is
-  #      <code>x = 0</code>, the second one solves <code>ax + b = 0</code>. The solution of the latter is
-  #      delegated to +Extmath.linsolve+. An array containing both results in ascending order is returned.
-  #    * <code>c != d</code>
-  #      The equation cannot be separated into <code>x</code> times some factor.
-  #      * <code>b == 0</code>
-  #        The equation to be solved is <code>ax**2 + c = d</code>. This can be written as the linear equation
-  #        <code>ay + c = d</code> with <code>y = x ** 2</code>. The solution of the linear equation is delegated
-  #        to +Extmath.linsolve+. If the returned value for +y+ is +nil+, that becomes the overall return value.
-  #        Otherwise an array containing the negative and positive squareroot of +y+ is returned
-  #      * <code>b != 0 </code>
-  #        The equation cannot be reduced to simpler cases. We now first have to compute what is called the
-  #        discriminant <code>x = b**2 + 4a(d - c)</code> (that's what we need to compute the square root of).
-  #        If the descriminant is negative no real solution exists and <code>nil</code> is returned. The ternary
-  #        operator checking whether <code>b</code> is negative does ensure better numerical stability --only one
-  #        of the two solutions is computed using the widely know formula for solving second order equations.
-  #        The second one is computed from the fact that the product of both solutions is <code>(c - d) / a</code>.
-  #        Take a look at a book on numerical mathematics if you don't understand why this should be done.
-  #
-  def self.sqsolve(a, b, c, d = 0.0)
-    if a == 0.0
-      x = linsolve(b, c, d)
-      return x.nil? ? nil: [ linsolve(b, c, d) ]
-    else
-      return [0.0, linsolve(a, b)].sort if c == d
-      if b == 0.0
-        x = Extmath.linsolve(a, c, d)
-        x < 0.0 ? nil : [-Math.sqrt(x), Math.sqrt(x)]
-      else
-        x = b * b + 4.0 * a * (d - c)
-        return nil if x < 0.0
-        x = b < 0 ? b - Math.sqrt(x) : b + Math.sqrt(x)
-        [-0.5 * x / a, 2.0 * (d - c) / x].sort
-      end
-    end
-  end
-
-end

data/src/standard/facets/math/std.rb

@@ -1,27 +0,0 @@
-require 'facets/math/variance'
-
-module Math
-
-  # Standard deviation of a sample.
-  #
-  def self.std(array, &block)
-    sqrt(variance(array, &block))
-  end
-
-  class << self
-    alias_method :standard_deviation, :std
-  end
-
-  # Standard deviation of a population.
-  #
-  def self.pstd(array, &block)
-    Math::sqrt(pvariance(array, &block))
-  end
-
-  # Calculates the standard error of a sample.
-  def self.stderr(array)
-    return 0.0 if array.size < 2
-    std(array) / sqrt(array.size)
-  end
-
-end

data/src/standard/facets/math/stderr.rb

@@ -1 +0,0 @@
-require 'facets/math/std'

data/src/standard/facets/math/sum.rb

@@ -1,16 +0,0 @@
-module Math
-
-  # Returns sum.  When a block is given, summation is taken over the 
-  # each result of block evaluation.
-  #
-  def self.sum(array) #:yield:
-    sum = 0.0
-    if block_given?
-      array.each{|i| sum += yield(i)}
-    else
-      array.each{|i| sum += i}
-    end
-    sum
-  end
-
-end

data/src/standard/facets/math/summed_sqdevs.rb

@@ -1,14 +0,0 @@
-require 'facets/math/sum'
-require 'facets/math/mean'
-
-module Math
-
-  # The sum of the squared deviations from the mean.
-  #
-  def self.summed_sqdevs(array)
-    return 0 if array.size < 2
-    m = mean(array)
-    sum(array.map{ |x| (x - m) ** 2 })
-  end
-
-end

data/src/standard/facets/math/theil_index.rb

@@ -1,24 +0,0 @@
-require 'facets/math/sum'
-require 'facets/math/mean'
-require 'facets/math/approx_equal'
-
-module Math
-
-  # Calculates the Theil index (a statistic used to measure
-  # economic inequality).
-  #
-  # TI = \sum_{i=1}^N \frac{x_i}{\sum_{j=1}^N x_j} ln \frac{x_i}{\bar{x}}
-  #
-  #   http://en.wikipedia.org/wiki/Theil_index
-  #
-  def self.theil_index(array)
-    return -1 if array.size <= 0 or any? { |x| x < 0 }
-    return  0 if array.size <  2 or all? { |x| approx_equal(x, 0) }
-    m = mean(array)
-    s = sum(array).to_f
-    inject(0) do |theil, xi|
-	    theil + ((xi > 0) ? (log(xi.to_f/m) * xi.to_f/s) : 0.0)
-    end
-  end
-
-end

data/src/standard/facets/math/variance.rb

@@ -1,31 +0,0 @@
-require 'facets/math/summed_sqdevs'
-
-module Math
-
-  #
-  def self.variance(array, &block)
-    sum2 = if block_given?
-      sum(array){ |i| j = block[i]; j*j }
-    else
-      sum(array){ |i| i**2 }
-    end
-    sum2/array.size - mean(array, &block)**2
-  end
-
-  # Variance of the sample.
-  # Variance of 0 or 1 elements is 0.0.
-  #
-  # TODO: Same as #variance? Then choose one.
-  def self.variance2(array)
-    return 0.0 if array.size < 2
-    summed_sqdevs(array) / (array.size - 1)
-  end
-
-  # Variance of a population.
-  # Variance of 0 or 1 elements is 0.0.
-  def self.pvariance(array)
-    return 0.0 if array.size < 2
-    summed_sqdevs(array) / array.size
-  end
-
-end

data/src/standard/facets/net/http.rb

@@ -1,32 +0,0 @@
-require 'net/http'
-
-module Net
-
-  # CREDIT: Daniel Huckstep
-  def self.download(url, limit=10)
-    raise ArgumentError, 'HTTP redirect too deep' if limit == 0
-    #url = URI.parse(url)
-    #req = Net::HTTP::Get.new(url.path)
-    #req['User-Agent'] = "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.7) Gecko/2009030422 Ubuntu/8.10 (intrepid) Firefox/3.0.7"
-    #resp = Net::HTTP.new(url.host, url.port).start { |http| http.request(req) }
-    resp = Net::HTTP.get_response(URI.parse(url))
-    case resp
-    when Net::HTTPSuccess     then resp
-    when Net::HTTPRedirection then download(resp['location'], limit - 1)
-    else resp.error!
-    end
-  end
-
-  # CREDIT: Daniel Huckstep
-  def self.download_and_save(url, path=nil)
-    if path.nil?
-      path = File.expand_path(url.split('/').last)
-    else
-      path = File.expand_path(path)
-    end
-    raise ArgumentError.new('Save path is a directory') if File.directory?(path)
-    resp = download(url)
-    open(path,'w') { |file| file.write(resp.body) } if resp.is_a?(Net::HTTPSuccess)
-  end
-end
-

data/src/standard/facets/ostruct.rb

@@ -1,210 +0,0 @@
-require 'ostruct'
-
-class OpenStruct
-
-  # Allows the initialization of an OpenStruct with a setter block:
-  #
-  #   person = OpenStruct.new do |o|
-  #     o.name    = 'John Smith'
-  #     o.gender  = :M
-  #     o.age     = 71
-  #   end
-  #
-  # You can still provide a hash for initialization purposes, and even combine
-  # the two approaches if you wish.
-  #
-  #   person = OpenStruct.new(:name => 'John Smith', :age => 31) do |p|
-  #     p.gender = :M
-  #   end
-  #
-  # Alternatively you can provide a default block:
-  #
-  #   stuff = OpenStruct.new{ |o,k| o[k] = [] }
-  #   stuff.place << :a
-  #   stuff.place << :b
-  #   stuff.place #=> [:a, :b]
-  #
-  # A setter block versus a defualt block is determined by the arity of
-  # the block. You can not provide both at the same time.
-  #
-  # CREDIT: Noah Gibbs, Gavin Sinclair
-  def initialize(hash=nil, &block)
-    if block && block.arity==2
-      @table = Hash.new(&block)
-    else
-      @table = {}
-    end
-    if hash
-      for k,v in hash
-        @table[k.to_sym] = v
-        new_ostruct_member(k)
-      end
-    end
-    if block && block.arity==1
-      yield self
-    end
-  end
-
-  #
-  def each(&blk)
-    @table.each(&blk)
-  end
-
-  #
-  def to_h
-    @table.dup
-  end
-
-  # Access a value in the OpenStruct by key, like a Hash.
-  # This increases OpenStruct's "duckiness".
-  #
-  #   o = OpenStruct.new
-  #   o.t = 4
-  #   o['t']  #=> 4
-  #
-  def [](key)
-    key = key.to_sym unless key.is_a?(Symbol)
-    @table[key]
-  end
-
-  # Set a value in the OpenStruct by key, like a Hash.
-  #
-  #   o = OpenStruct.new
-  #   o['t'] = 4
-  #   o.t  #=> 4
-  #
-  def []=(key,val)
-    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
-    key = key.to_sym unless key.is_a?(Symbol)
-    @table[key]=val
-  end
-
-  # Provides access to an OpenStruct's inner table.
-  #
-  #   o = OpenStruct.new
-  #   o.a = 1
-  #   o.b = 2
-  #   o.instance_delegate.map { |k, v| "#{k} #{v}" }
-  #   #=> ["a 1", "b 2"]
-  #
-  def instance_delegate
-    @table
-  end
-
-  #
-  alias ostruct_delegate instance_delegate
-
-  # Insert/update hash data on the fly.
-  #
-  #   o = OpenStruct.new
-  #   o.ostruct_update(:a => 2)
-  #   o.a  #=> 2
-  #
-  def ostruct_update(other)
-    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
-    ##other = other.to_hash  #to_h ?
-    for k,v in other
-      @table[k.to_sym] = v
-    end
-    self
-  end
-
-  # Merge hash data creating a new OpenStruct object.
-  #
-  #   o = OpenStruct.new
-  #   x = o.ostruct_merge(:a => 2)
-  #   x.a  #=> 2
-  #
-  def ostruct_merge(other)
-    o = dup
-    o.ostruct_update(other)
-    o
-  end
-
-  #--
-  # TO BE DEPRECATED
-  # Must consider that accessing instance_delegate instead can be dangerous.
-  # Might we us a Functor to ensure the table keys are always symbols?
-  #++
-
-  # Insert/update hash data on the fly.
-  #
-  #   o = OpenStruct.new
-  #   o.ostruct_update(:a => 2)
-  #   o.a  #=> 2
-  #
-  def __update__(other)
-    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
-    ##other = other.to_hash #to_h?
-    for k,v in other
-      @table[k.to_sym] = v
-    end
-    self
-  end
-
-  # Merge hash data creating a new OpenStruct object.
-  #
-  #   o = OpenStruct.new
-  #   x = o.ostruct_merge(:a => 2)
-  #   x.a  #=> 2
-  #
-  def __merge__(other)
-    o = dup
-    o.__update__(other)
-    o
-  end
-
-  #
-  def to_ostruct
-    self
-  end
-
-end
-
-
-class Hash
-
-  # Turns a hash into a generic object using an OpenStruct.
-  #
-  #   o = {'a' => 1}.to_ostruct
-  #   o.a  #=> 1
-  #
-  def to_ostruct
-    OpenStruct.new(self)
-  end
-
-  # Like to_ostruct but recusively objectifies all hash elements as well.
-  #
-  #   o = {'a' => { 'b' => 1 }}.to_ostruct_recurse
-  #   o.a.b  #=> 1
-  #
-  # The +exclude+ parameter is used internally to prevent infinite
-  # recursion and is not intended to be utilized by the end-user.
-  # But for more advance use, if there is a particular subhash you
-  # would like to prevent from being converted to an OpoenStruct
-  # then include it in the +exclude+ hash referencing itself. Eg.
-  #
-  #   h = { 'a' => { 'b' => 1 } }
-  #   o = h.to_ostruct_recurse( { h['a'] => h['a'] } )
-  #   o.a['b']  #=> 1
-  #
-  # CREDIT: Alison Rowland, Jamie Macey, Mat Schaffer
-  def to_ostruct_recurse(exclude={})
-    return exclude[self] if exclude.key?( self )
-    o = exclude[self] = OpenStruct.new
-    h = self.dup
-    each_pair do |k,v|
-      h[k] = v.to_ostruct_recurse( exclude ) if v.respond_to?(:to_ostruct_recurse)
-    end
-    o.__update__(h)
-  end
-end
-
-class NilClass
-  # Create an empty OpenStruct object.
-  def to_ostruct
-    OpenStruct.new
-  end
-end
-
-# Copyright (c) 2005 Thomas Sawyer (Ruby License)