facets 2.9.2 → 2.9.3

data/lib/standard/facets/math/lgamma.rb

@@ -2,7 +2,9 @@ module Math
 
   unless defined?(lgamma)
 
-    # Logarithmus naturalis of gamma function of +x+
+    # Logarithmus naturalis of gamma function of +x+.
+    #
+    # @author Josef Schugt
     def self.lgamma(x)
       h  = x + 5.5
       h -= (x + 0.5) * log(h)

data/lib/standard/facets/math/linsolve.rb

@@ -3,6 +3,8 @@ module Math
   # Returns real solution(s) of <code>+a+x + +b+ = +c+</code> or +nil+
   # if no or an infinite number of solutions exist. If
   # <code>c</code> is missing it is assumed to be 0.
+  #
+  # @author Josef Schugt
   def self.linsolve(a, b, c = 0.0)
     a == 0 ? nil : (c - b) / a
   end

data/lib/standard/facets/math/median.rb

@@ -1,15 +1,30 @@
+require 'facets/math/percentile'
+
 module Math
 
+  # Returns the numerical median for the an array of values;
+  # or nil if array is empty.
+  #
+  def self.median(array)
+    percentile(array, 50)
+  end
+
+# better definition ?
+=begin
   #
   def self.median(array)
     return 0 if array.size == 0
+
     tmp = array.sort
     mid = tmp.size / 2
+
     if (tmp.size % 2) == 0
 	    (tmp[mid-1] + tmp[mid]).to_f / 2
     else
 	    tmp[mid]
     end
   end
+=end
 
 end
+

data/lib/standard/facets/math/percentile.rb

@@ -0,0 +1,40 @@
+module Math
+
+  # Returns the percentile value for percentile _pcnt_; nil if array is empty.
+  #
+  # +pcnt+ should be expressed as an integer, e.g. `percentile(90)` returns
+  # the 90th percentile of the array.
+  #
+  # Algorithm from NIST[http://www.itl.nist.gov/div898/handbook/prc/section2/prc252.htm]
+  #
+  # NOTE: This is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT: Ben Koski
+  #
+  # @non-core
+  #   require 'facets/array/precentile'
+  #
+  def self.percentile(array, pcnt)
+    sorted_array = array.sort
+
+    return nil if array.length == 0
+
+    rank  = (pcnt.to_f / 100) * (array.length + 1)
+    whole = rank.truncate
+ 
+    # if has fractional part
+    if whole != rank
+      s0 = sorted_array[whole - 1]
+      s1 = sorted_array[whole]
+
+      f = (rank - rank.truncate).abs
+
+      return (f * (s1 - s0)) + s0
+    else
+      return sorted_array[whole - 1]
+    end
+  end
+  
+end
+

data/lib/standard/facets/math/round.rb

@@ -0,0 +1,9 @@
+module Math
+
+  # Round number to an integer.
+  #
+  def self.round(x)
+    x.round
+  end
+
+end

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

@@ -1,11 +1,12 @@
+require 'facets/math/linsolve'
+
 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:
+  # In order to solve <code>ax**2 + bx + c = d</code> +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
@@ -15,13 +16,13 @@ module Math
   #    * <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.
+  #      delegated to +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.
+  #        to +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
@@ -32,6 +33,7 @@ module Math
   #        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.
   #
+  # @author Josef Schugt
   def self.sqsolve(a, b, c, d = 0.0)
     if a == 0.0
       x = linsolve(b, c, d)
@@ -39,7 +41,7 @@ module Math
     else
       return [0.0, linsolve(a, b)].sort if c == d
       if b == 0.0
-        x = Extmath.linsolve(a, c, d)
+        x = linsolve(a, c, d)
         x < 0.0 ? nil : [-Math.sqrt(x), Math.sqrt(x)]
       else
         x = b * b + 4.0 * a * (d - c)

data/lib/standard/facets/math/tgamma.rb

@@ -0,0 +1,10 @@
+require 'facets/math/lgamma'
+
+module Math
+
+  # Exp of LGamma.
+  def self.tgamma(x)
+    exp(lgamma(x))
+  end
+
+end

data/lib/standard/facets/pathname.rb

@@ -232,9 +232,22 @@ end
 class NilClass
   # Provide platform dependent null path.
   #
-  # CREDIT Daniel Burger
+  # @standard
+  #   require 'facets/pathname'
+  #
+  # @author Daniel Burger
   def to_path
     Pathname.null
   end
 end
 
+class Array
+  # Convert array to Pathname instance.
+  #
+  # @standard
+  #   require 'facets/pathname'
+  #
+  def to_path
+    Pathname.new(join('/'))
+  end
+end

data/lib/standard/facets/set.rb

@@ -3,9 +3,10 @@ require 'set'
 class Set
 
   #
+  # @author Phrogz
   def power_set
     if empty?
-      Set[ self ]
+      Set[self]
     else
       any_value = [to_a.first]
       subsubs = (self - any_value).power_set
@@ -16,7 +17,10 @@ end
 
 class Array
 
+  # TODO: Move to Array extensions.
+
   #
+  # @author Phrogz
   def power_set
     if empty?
       [self]

data/{src/supplemental → lib/standard}/facets/timer.rb

@@ -116,7 +116,8 @@ class Timer
   # Kill time limit thread, if any.
   def defuse
     if @timer_thread
-      Thread.kill @timer_thread
+      #Thread.kill @timer_thread
+      @timer_thread.kill
       @timer_thread = nil
     end
   end
@@ -204,4 +205,4 @@ class Timer
 
 end #class Timer
 
-# Copyright (c) 2004 Thomas Sawyer (Ruby License)
+# Copyright (c) 2004 Rubyworks

data/qed/applique/file_helpers.rb

@@ -13,7 +13,7 @@ Before :document do
 end
 
 When /Given a directory '(.*?)' containing/ do |dir, text|
-  abort unless /^#{temporary_directory}/ =~ dir
+  #abort unless /^#{temporary_directory}/ =~ dir
   text.lines.each do |file|
     next if file =~ /^\s*$/
     file = File.join(dir, file.strip)

data/qed/core/dir/multiglob.rdoc

@@ -3,7 +3,7 @@
 Dir#multglob is like Dir#glob but it can handle more than one match
 parameter at a time.
 
-Given a directory 'tmp/multiglob' containing ...
+Given a directory 'multiglob' containing:
 
   A.txt
   A/B.txt
@@ -14,11 +14,11 @@ We can use #multglob to find multiple matches.
   require 'facets/dir/multiglob'
 
   x = %w{
-    tmp/multiglob/A
-    tmp/multiglob/A.txt
+    multiglob/A
+    multiglob/A.txt
   }
 
-  r = Dir.multiglob('tmp/multiglob/A', 'tmp/multiglob/A.*').sort
+  r = Dir.multiglob('multiglob/A', 'multiglob/A.*').sort
 
   r.assert == x
 
@@ -28,14 +28,14 @@ Dir#multiglob_r is like #multiglob but automatically searches
 directories recrusively.
 
   x = %w{
-    tmp/multiglob/A 
-    tmp/multiglob/A/B
-    tmp/multiglob/A.txt
-    tmp/multiglob/A/B.txt
-    tmp/multiglob/A/B/C.txt
+    multiglob/A 
+    multiglob/A/B
+    multiglob/A.txt
+    multiglob/A/B.txt
+    multiglob/A/B/C.txt
   }.sort
 
-  r = Dir.multiglob_r('tmp/multiglob/*').sort
+  r = Dir.multiglob_r('multiglob/*').sort
 
   r.assert == x
 

data/qed/core/dir/recurse.rdoc

@@ -1,6 +1,6 @@
 == Dir#recurse
 
-Given a directory 'tmp/recurse' containing ...
+Given a directory 'recurse' containing:
 
   A.txt
   A/B.txt
@@ -12,14 +12,14 @@ list of all the entries.
   require 'facets/dir/recurse'
 
   x = %w{
-    tmp/recurse/A
-    tmp/recurse/A.txt
-    tmp/recurse/A/B
-    tmp/recurse/A/B.txt
-    tmp/recurse/A/B/C.txt
+    recurse/A
+    recurse/A.txt
+    recurse/A/B
+    recurse/A/B.txt
+    recurse/A/B/C.txt
   }.sort
 
-  r = Dir.recurse('tmp/recurse').sort
+  r = Dir.recurse('recurse').sort
 
   r.assert == x
 
@@ -29,13 +29,13 @@ Dir#ls_r is an alias for #recurse which can also be used to gather
 a complete recursive list of all the entries.
 
   x = %w{
-    tmp/recurse/A
-    tmp/recurse/A.txt
-    tmp/recurse/A/B
-    tmp/recurse/A/B.txt
-    tmp/recurse/A/B/C.txt
+    recurse/A
+    recurse/A.txt
+    recurse/A/B
+    recurse/A/B.txt
+    recurse/A/B/C.txt
   }.sort
 
-  r = Dir.ls_r('tmp/recurse').sort
+  r = Dir.ls_r('recurse').sort
 
   r.assert == x

data/qed/core/string/camelcase.rdoc

@@ -4,58 +4,38 @@
 
 The `camelcase` method converts snakecase strings into camelcase strings.
 
-  "abc_xyz".camelcase.assert == "AbcXyz"
+  "abc_xyz".camelcase.assert == "abcXyz"
 
 Continious underscore characters are treated as if a single underscore
 character.
 
-  "abc____xyz".camelcase.assert == "AbcXyz"
+  "abc____xyz".camelcase.assert == "abcXyz"
 
-Without an argument the first character is capitalized.
+Without an argument the first character is left alone.
 
   "Camel_case".camelcase.assert == "CamelCase"
 
-Passing +true+ to #camelcase uncaptializes the first letter. This is
-known as lower-camelcase.
+Passing +:upper+ or +true+ to #camelcase captializes the first letter.
+This is known as upper-camelcase.
 
-  "Abc_xyz".camelcase(true).assert == "abcXyz"
-  "Abc____xyz".camelcase(true).assert == "abcXyz"
+  "Abc_xyz".camelcase(true).assert == "AbcXyz"
+  "Abc____xyz".camelcase(:upper).assert == "AbcXyz"
 
-Where as passing +false+ leaves the first as it was given, known as
-inter-camelcase.
+Where as passing +false+ or +:lower+ downcases the first character,
+known as lower-camelcase.
 
   "abc_xyz".camelcase(false).assert == "abcXyz"
   "abc____xyz".camelcase(false).assert == "abcXyz"
-  "Abc_xyz".camelcase(false).assert == "AbcXyz"
-  "Abc____xyz".camelcase(false).assert == "AbcXyz"
-
-The #camelcase method applies to each word in a string.
-
-  #Unit :camelcase => "converts spaces to captialized" do
-  #  "abc xyz".camelcase.assert  == "AbcXyz"
-  #  "abc  xyz".camelcase.assert == "AbcXyz"
-  #  "abc\txyz".camelcase.assert == "AbcXyz"
-  #  "abc\nxyz".camelcase.assert == "AbcXyz"
-  #end
-
-  #Unit :camelcase => "false converts spaces to captialized" do
-  #  "abc xyz".camelcase(false).assert == "abcXyz"
-  #  "abc  xyz".camelcase(false).assert == "abcXyz"
-  #  "abc\txyz".camelcase(false).assert == "abcXyz"
-  #  "abc\nxyz".camelcase(false).assert == "abcXyz"
-  #end
-
-In addition #camelcase converts path separators ('/') to module name
-separators ('::').
-
-  'this_is_it'.camelcase.assert == 'ThisIsIt'
-  'my_module/my_class'.camelcase.assert == 'MyModule::MyClass'
-  '/my_module/my_class'.camelcase.assert == '::MyModule::MyClass'
-
-  #Unit :camelcase => "converts methods to module names" do
-  #  'my_module__my_class'.camelcase.assert == 'MyModule::MyClass'
-  #  '__my_module__my_class'.camelcase.assert == '::MyModule::MyClass'
-  #end
+  "Abc_xyz".camelcase(:lower).assert == "abcXyz"
+  "Abc____xyz".camelcase(:lower).assert == "abcXyz"
+
+By passing a match string to the method we can make +camelcase+ 
+apply to each word in a string.
+
+  "abc xyz".camelcase(' ').assert  == "abcXyz"
+  "abc  xyz".camelcase(/\s/).assert == "abcXyz"
+  "abc\txyz".camelcase(/\s/).assert == "abcXyz"
+  "abc\nxyz".camelcase(/\s/).assert == "abcXyz"
 
 == String#lower_camelcase
 

data/qed/core/string/snakecase.rdoc

@@ -2,8 +2,9 @@
 
   require 'facets/string/snakecase'
 
-  '/my_module/my_class/'.snakecase.assert == '/my_module/my_class/'
-  'MyModule::MyClass'.snakecase.assert == 'my_module/my_class'
-  '::MyClass'.snakecase.assert == '/my_class'
+  'my_name'.snakecase.assert == 'my_name'
+
+  'MyName'.snakecase.assert == 'my_name'
+
   'URI'.snakecase.assert == 'uri'