compsci 0.0.3.1 → 0.1.0.1

data/lib/compsci/fit.rb

@@ -1,137 +1,137 @@
-require 'compsci'
-
-module CompSci::Fit
-  #
-  # functions below originally copied from https://github.com/seattlrb/minitest
-  #
-
-  ##
-  # Enumerates over +enum+ mapping +block+ if given, returning the
-  # sum of the result. Eg:
-  #
-  #   sigma([1, 2, 3])                # => 1 + 2 + 3 => 7
-  #   sigma([1, 2, 3]) { |n| n ** 2 } # => 1 + 4 + 9 => 14
-
-  def self.sigma enum, &block
-    enum = enum.map(&block) if block
-    enum.inject { |sum, n| sum + n }
-  end
-
-  ##
-  # Takes an array of x/y pairs and calculates the general R^2 value to
-  # measure fit against a predictive function,  which is the block supplied
-  # to error:
-  #
-  # e.g. error(xys) { |x| 5 + 2 * x }
-  #
-  # See: http://en.wikipedia.org/wiki/Coefficient_of_determination
-  #
-
-  def self.error xys, &blk
-    y_bar  = sigma(xys) { |_, y| y                   } / xys.size.to_f
-    ss_tot = sigma(xys) { |_, y| (y - y_bar)    ** 2 }
-    ss_res = sigma(xys) { |x, y| (yield(x) - y) ** 2 }
-
-    1 - (ss_res / ss_tot)
-  end
-
-  ##
-  # Fits the functional form: a (+ 0x)
-  #
-  # Takes x and y values and returns [a, variance]
-  #
-
-  def self.constant xs, ys
-    # written by Rick
-    y_bar = sigma(ys) / ys.size.to_f
-    variance = sigma(ys) { |y| (y - y_bar) ** 2 }
-    [y_bar, variance]
-  end
-
-  ##
-  # To fit a functional form: y = a + b*ln(x).
-  #
-  # Takes x and y values and returns [a, b, r^2].
-  #
-  # See: http://mathworld.wolfram.com/LeastSquaresFittingLogarithmic.html
-
-  def self.logarithmic xs, ys
-    n     = xs.size
-    xys   = xs.zip(ys)
-    slnx2 = sigma(xys) { |x, _| Math.log(x) ** 2 }
-    slnx  = sigma(xys) { |x, _| Math.log(x)      }
-    sylnx = sigma(xys) { |x, y| y * Math.log(x)  }
-    sy    = sigma(xys) { |_, y| y                }
-
-    c = n * slnx2 - slnx ** 2
-    b = ( n * sylnx - sy * slnx ) / c
-    a = (sy - b * slnx) / n
-
-    return a, b, self.error(xys) { |x| a + b * Math.log(x) }
-  end
-
-  ##
-  # Fits the functional form: a + bx.
-  #
-  # Takes x and y values and returns [a, b, r^2].
-  #
-  # See: http://mathworld.wolfram.com/LeastSquaresFitting.html
-
-  def self.linear xs, ys
-    n   = xs.size
-    xys = xs.zip(ys)
-    sx  = sigma xs
-    sy  = sigma ys
-    sx2 = sigma(xs)  { |x|   x ** 2 }
-    sxy = sigma(xys) { |x, y| x * y  }
-
-    c = n * sx2 - sx**2
-    a = (sy * sx2 - sx * sxy) / c
-    b = ( n * sxy - sx * sy ) / c
-
-    return a, b, self.error(xys) { |x| a + b * x }
-  end
-
-  ##
-  # To fit a functional form: y = ae^(bx).
-  #
-  # Takes x and y values and returns [a, b, r^2].
-  #
-  # See: http://mathworld.wolfram.com/LeastSquaresFittingExponential.html
-
-  def self.exponential xs, ys
-    n     = xs.size
-    xys   = xs.zip(ys)
-    sxlny = sigma(xys) { |x, y| x * Math.log(y) }
-    slny  = sigma(xys) { |_, y| Math.log(y)     }
-    sx2   = sigma(xys) { |x, _| x * x           }
-    sx    = sigma xs
-
-    c = n * sx2 - sx ** 2
-    a = (slny * sx2 - sx * sxlny) / c
-    b = ( n * sxlny - sx * slny ) / c
-
-    return Math.exp(a), b, self.error(xys) { |x| Math.exp(a + b * x) }
-  end
-
-  ##
-  # To fit a functional form: y = ax^b.
-  #
-  # Takes x and y values and returns [a, b, r^2].
-  #
-  # See: http://mathworld.wolfram.com/LeastSquaresFittingPowerLaw.html
-
-  def self.power xs, ys
-    n       = xs.size
-    xys     = xs.zip(ys)
-    slnxlny = sigma(xys) { |x, y| Math.log(x) * Math.log(y) }
-    slnx    = sigma(xs)  { |x   | Math.log(x)               }
-    slny    = sigma(ys)  { |   y| Math.log(y)               }
-    slnx2   = sigma(xs)  { |x   | Math.log(x) ** 2          }
-
-    b = (n * slnxlny - slnx * slny) / (n * slnx2 - slnx ** 2)
-    a = (slny - b * slnx) / n
-
-    return Math.exp(a), b, self.error(xys) { |x| (Math.exp(a) * (x ** b)) }
+module CompSci
+  module Fit
+    #
+    # functions below originally from https://github.com/seattlrb/minitest
+    #
+
+    ##
+    # Enumerates over +enum+ mapping +block+ if given, returning the
+    # sum of the result. Eg:
+    #
+    #   sigma([1, 2, 3])                # => 1 + 2 + 3 => 7
+    #   sigma([1, 2, 3]) { |n| n ** 2 } # => 1 + 4 + 9 => 14
+
+    def self.sigma enum, &block
+      enum = enum.map(&block) if block
+      enum.inject { |sum, n| sum + n }
+    end
+
+    ##
+    # Takes an array of x/y pairs and calculates the general R^2 value to
+    # measure fit against a predictive function,  which is the block supplied
+    # to error:
+    #
+    # e.g. error(xys) { |x| 5 + 2 * x }
+    #
+    # See: http://en.wikipedia.org/wiki/Coefficient_of_determination
+    #
+
+    def self.error xys, &blk
+      y_bar  = sigma(xys) { |_, y| y                   } / xys.size.to_f
+      ss_tot = sigma(xys) { |_, y| (y - y_bar)    ** 2 }
+      ss_res = sigma(xys) { |x, y| (yield(x) - y) ** 2 }
+
+      1 - (ss_res / ss_tot)
+    end
+
+    ##
+    # Fits the functional form: a (+ 0x)
+    #
+    # Takes x and y values and returns [a, variance]
+    #
+
+    def self.constant xs, ys
+      # written by Rick
+      y_bar = sigma(ys) / ys.size.to_f
+      variance = sigma(ys) { |y| (y - y_bar) ** 2 }
+      [y_bar, variance]
+    end
+
+    ##
+    # To fit a functional form: y = a + b*ln(x).
+    #
+    # Takes x and y values and returns [a, b, r^2].
+    #
+    # See: http://mathworld.wolfram.com/LeastSquaresFittingLogarithmic.html
+
+    def self.logarithmic xs, ys
+      n     = xs.size
+      xys   = xs.zip(ys)
+      slnx2 = sigma(xys) { |x, _| Math.log(x) ** 2 }
+      slnx  = sigma(xys) { |x, _| Math.log(x)      }
+      sylnx = sigma(xys) { |x, y| y * Math.log(x)  }
+      sy    = sigma(xys) { |_, y| y                }
+
+      c = n * slnx2 - slnx ** 2
+      b = ( n * sylnx - sy * slnx ) / c
+      a = (sy - b * slnx) / n
+
+      return a, b, self.error(xys) { |x| a + b * Math.log(x) }
+    end
+
+    ##
+    # Fits the functional form: a + bx.
+    #
+    # Takes x and y values and returns [a, b, r^2].
+    #
+    # See: http://mathworld.wolfram.com/LeastSquaresFitting.html
+
+    def self.linear xs, ys
+      n   = xs.size
+      xys = xs.zip(ys)
+      sx  = sigma xs
+      sy  = sigma ys
+      sx2 = sigma(xs)  { |x|   x ** 2 }
+      sxy = sigma(xys) { |x, y| x * y  }
+
+      c = n * sx2 - sx**2
+      a = (sy * sx2 - sx * sxy) / c
+      b = ( n * sxy - sx * sy ) / c
+
+      return a, b, self.error(xys) { |x| a + b * x }
+    end
+
+    ##
+    # To fit a functional form: y = ae^(bx).
+    #
+    # Takes x and y values and returns [a, b, r^2].
+    #
+    # See: http://mathworld.wolfram.com/LeastSquaresFittingExponential.html
+
+    def self.exponential xs, ys
+      n     = xs.size
+      xys   = xs.zip(ys)
+      sxlny = sigma(xys) { |x, y| x * Math.log(y) }
+      slny  = sigma(xys) { |_, y| Math.log(y)     }
+      sx2   = sigma(xys) { |x, _| x * x           }
+      sx    = sigma xs
+
+      c = n * sx2 - sx ** 2
+      a = (slny * sx2 - sx * sxlny) / c
+      b = ( n * sxlny - sx * slny ) / c
+
+      return Math.exp(a), b, self.error(xys) { |x| Math.exp(a + b * x) }
+    end
+
+    ##
+    # To fit a functional form: y = ax^b.
+    #
+    # Takes x and y values and returns [a, b, r^2].
+    #
+    # See: http://mathworld.wolfram.com/LeastSquaresFittingPowerLaw.html
+
+    def self.power xs, ys
+      n       = xs.size
+      xys     = xs.zip(ys)
+      slnxlny = sigma(xys) { |x, y| Math.log(x) * Math.log(y) }
+      slnx    = sigma(xs)  { |x   | Math.log(x)               }
+      slny    = sigma(ys)  { |   y| Math.log(y)               }
+      slnx2   = sigma(xs)  { |x   | Math.log(x) ** 2          }
+
+      b = (n * slnxlny - slnx * slny) / (n * slnx2 - slnx ** 2)
+      a = (slny - b * slnx) / n
+
+      return Math.exp(a), b, self.error(xys) { |x| (Math.exp(a) * (x ** b)) }
+    end
   end
 end

data/lib/compsci/heap.rb

@@ -1,6 +1,4 @@
-require 'compsci/tree'
-
-include CompSci
+require 'compsci/complete_tree'
 
 # A Heap is a partially sorted, complete N-ary tree with the property:
 # * Every node has a value larger (or smaller) than that of its children
@@ -20,7 +18,7 @@ include CompSci
 #   swap nodes at each layer of the tree, and there are log(n, base b) layers
 #   to the tree.
 #
-class Heap < CompleteNaryTree
+class CompSci::Heap < CompSci::CompleteNaryTree
   # * defaults to a MaxHeap, with the largest node at the root
   # * specify a minheap with minheap: true or cmp_val: -1
   #
@@ -39,8 +37,8 @@ class Heap < CompleteNaryTree
   # * sift_up -- O(log n) on heap size
   #
   def push(node)
-    @store << node
-    self.sift_up(@store.size - 1)
+    @array.push(node)
+    self.sift_up(@array.size - 1)
   end
 
   # * remove from the front of the array
@@ -48,9 +46,9 @@ class Heap < CompleteNaryTree
   # * sift_down -- O(log n) on heap size
   #
   def pop
-    node = @store.shift
-    replacement = @store.pop
-    @store.unshift replacement if replacement
+    node = @array.shift
+    replacement = @array.pop
+    @array.unshift replacement if replacement
     self.sift_down(0)
     node
   end
@@ -58,7 +56,7 @@ class Heap < CompleteNaryTree
   # * return what pop would return (avoid sifting)
   #
   def peek
-    @store.first
+    @array.first
   end
 
   # * called recursively
@@ -69,7 +67,7 @@ class Heap < CompleteNaryTree
     return self if idx <= 0
     pidx = self.class.parent_idx(idx, @child_slots)
     if !self.heapish?(pidx, idx)
-      @store[idx], @store[pidx] = @store[pidx], @store[idx]   # swap
+      @array[idx], @array[pidx] = @array[pidx], @array[idx]   # swap
       self.sift_up(pidx)
     end
     self
@@ -81,12 +79,12 @@ class Heap < CompleteNaryTree
   # * slower than sift_up because one parent vs multiple children
   #
   def sift_down(idx)
-    return self if idx >= @store.size
+    return self if idx >= @array.size
     cidxs = self.class.children_idx(idx, @child_slots)
     # promote the heapiest child
     cidx = self.heapiest(cidxs)
     if !self.heapish?(idx, cidx)
-      @store[idx], @store[cidx] = @store[cidx], @store[idx]   # swap
+      @array[idx], @array[cidx] = @array[cidx], @array[idx]   # swap
       self.sift_down(cidx)
     end
     self
@@ -95,7 +93,7 @@ class Heap < CompleteNaryTree
   # are values of parent and child (by index) in accordance with heap property?
   #
   def heapish?(pidx, cidx)
-    (@store[pidx] <=> @store[cidx]) != (@cmp_val * -1)
+    (@array[pidx] <=> @array[cidx]) != (@cmp_val * -1)
   end
 
   # return the heapiest idx in cidxs
@@ -103,7 +101,7 @@ class Heap < CompleteNaryTree
   def heapiest(cidxs)
     idx = cidxs.first
     cidxs.each { |cidx|
-      idx = cidx if cidx < @store.size and self.heapish?(cidx, idx)
+      idx = cidx if cidx < @array.size and self.heapish?(cidx, idx)
     }
     idx
   end
@@ -116,99 +114,7 @@ class Heap < CompleteNaryTree
     check_children = []
     self.class.children_idx(idx, @child_slots).each { |cidx|
       # cidx is arithmetically produced; the corresponding child may not exist
-      if cidx < @store.size
-        return false unless self.heapish?(idx, cidx)
-        check_children << cidx
-      end
-    }
-    check_children.each { |cidx| return false unless self.heap?(idx: cidx) }
-    true
-  end
-end
-
-#
-# LEGACY BELOW untouched for now
-#
-
-class BinaryHeap < CompleteBinaryTree
-  # defaults to a MaxHeap, with the largest node at the root
-  # specify a minheap with minheap: true or cmp_val: -1
-  #
-  def initialize(cmp_val: 1, minheap: false)
-    super()
-    cmp_val = -1 if minheap
-    case cmp_val
-    when -1, 1
-      @cmp_val = cmp_val
-    else
-      raise(ArgumentError, "unknown comparison value: #{cmp_val}")
-    end
-  end
-
-  # append to the array
-  # sift_up -- O(log n) on heap size
-  def push(node)
-    @store << node
-    self.sift_up(@store.size - 1)
-  end
-
-  # remove from the front of the array
-  # move last node to root
-  # sift_down -- O(log n) on heap size
-  def pop
-    node = @store.shift
-    replacement = @store.pop
-    @store.unshift replacement if replacement
-    self.sift_down(0)
-    node
-  end
-
-  # return what pop would return (avoid sifting)
-  def peek
-    @store.first
-  end
-
-  # called recursively
-  # idx represents the node suspected to violate the heap
-  # intended to be O(log n) on heap size
-  def sift_up(idx)
-    return self if idx <= 0
-    pidx = self.class.parent_idx(idx)
-    if !self.heapish?(pidx, idx)
-      @store[idx], @store[pidx] = @store[pidx], @store[idx]   # swap
-      self.sift_up(pidx)
-    end
-    self
-  end
-
-  # called recursively
-  # idx represents the node suspected to violate the heap
-  # intended to be O(log n) on heap size
-  def sift_down(idx)
-    return self if idx >= @store.size
-    lidx, ridx = self.class.children_idx(idx)
-    # promote the heapiest child
-    cidx = self.heapish?(lidx, ridx) ? lidx : ridx
-    if !self.heapish?(idx, cidx)
-      @store[idx], @store[cidx] = @store[cidx], @store[idx]   # swap
-      self.sift_down(cidx)
-    end
-    self
-  end
-
-  # are values of parent and child (by index) in accordance with heap property?
-  def heapish?(pidx, cidx)
-    (@store[pidx] <=> @store[cidx]) != (@cmp_val * -1)
-  end
-
-  # not used internally
-  # checks that every node satisfies the heap property
-  # calls heapish? on idx's children and then heap? on them recursively
-  def heap?(idx: 0)
-    check_children = []
-    self.class.children_idx(idx).each { |cidx|
-      # cidx is arithmetically produced; the corresponding child may not exist
-      if cidx < @store.size
+      if cidx < @array.size
         return false unless self.heapish?(idx, cidx)
         check_children << cidx
       end