compsci 0.1.1.1 → 0.2.0.1

data/lib/compsci/fit.rb

@@ -1,5 +1,38 @@
 module CompSci
   module Fit
+    ##
+    # Fits the functional form: a (+ 0x)
+    #
+    # Takes x and y values and returns [a, variance]
+    #
+
+    def self.constant xs, ys
+      y_bar = sigma(ys) / ys.size.to_f
+      variance = sigma(ys) { |y| (y - y_bar) ** 2 }
+      [y_bar, variance]
+    end
+
+    ##
+    # Run logarithmic, linear, exponential, and power fits
+    # Return the stats for the best fit (highest r^2)
+    #
+    # Takes x and y values and returns [a, b, r2, fn]
+    #
+
+    def self.best xs, ys
+      vals = []
+      max_r2 = 0
+      [:logarithmic, :linear, :exponential, :power].each { |fn|
+        a, b, r2 = Fit.send(fn, xs, ys)
+        # p [a, b, r2, fn]
+        if r2 > max_r2
+          vals = [a, b, r2, fn]
+          max_r2 = r2
+        end
+      }
+      vals
+    end
+
     #
     # functions below originally from https://github.com/seattlrb/minitest
     #
@@ -8,7 +41,7 @@ module CompSci
     # 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])                # => 1 + 2 + 3 => 6
     #   sigma([1, 2, 3]) { |n| n ** 2 } # => 1 + 4 + 9 => 14
 
     def self.sigma enum, &block
@@ -34,19 +67,6 @@ module CompSci
       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).
     #

data/lib/compsci/names.rb

@@ -1,5 +1,8 @@
 module CompSci
   module Names
+    ENGLISH_UPPER = [*'A'..'Z']
+    ENGLISH_LOWER = [*'a'..'z']
+
     WW1 = [:apples, :butter, :charlie, :duff, :edward, :freddy, :george,
            :harry, :ink, :johnnie, :king, :london, :monkey, :nuts, :orange,
            :pudding, :queenie, :robert, :sugar, :tommy, :uncle, :vinegar,
@@ -14,12 +17,8 @@ module CompSci
     CRYPTO = [:alice, :bob, :charlie, :david, :eve, :frank, :grace, :heidi,
               :judy, :mallory, :olivia, :peggy, :sybil, :trudy, :victor,
               :wendy]
-    ENGLISH_UPPER = [*'A'..'Z']
-    ENGLISH_LOWER = [*'a'..'z']
-
     PLANETS = [:mercury, :venus, :earth, :mars, :jupiter, :saturn, :uranus,
                :neptune, :pluto]
-
     SOLAR = [:mercury, :venus, :earth, :mars, :asteroid_belt, :jupiter,
              :saturn, :uranus, :neptune, :kuiper_belt, :scattered_disk,
              :heliosphere]

data/lib/compsci/node.rb

@@ -1,31 +1,29 @@
 module CompSci
-  # has a value and an array of children
+  # has a value and an array of children; allows child gaps
   class Node
     attr_accessor :value
     attr_reader :children
 
-    def initialize(value)
+    def initialize(value, children: [])
       @value = value
-      @children = []
+      if children.is_a?(Integer)
+        @children = Array.new(children)
+      else
+        @children = children
+      end
       # @metadata = {}
     end
 
-    def add_child(node)
-      @children << node
-    end
-
-    def new_child(value)
-      self.add_child self.class.new(value)
-    end
-
-    def add_parent(node)
-      node.add_child(self)
-    end
-
     def to_s
       @value.to_s
     end
 
+    # This could be done directly with self.children, but #set_child is part
+    # of the Node API.
+    def set_child(idx, node)
+      @children[idx] = node
+    end
+
     def inspect
       "#<%s:0x%0xi @value=%s @children=[%s]>" %
         [self.class,
@@ -35,13 +33,44 @@ module CompSci
     end
   end
 
+  # adds a key to Node; often the key is used to place the node in the
+  # tree, independent of the value; e.g. key=priority, value=process_id
+  class KeyNode < Node
+    attr_accessor :key
+
+    def initialize(val, key: nil, children: [])
+      @key = key
+      super(val, children: children)
+    end
+
+    def to_s
+      [key, value].join(':')
+    end
+  end
+
+  # accumulate children; no child gaps
+  class FlexNode < Node
+    def add_child(node)
+      @children << node
+    end
+
+    # TODO: are we passing everything needed to self.class.new ?
+    def new_child(value)
+      self.add_child self.class.new(value)
+    end
+
+    def add_parent(node)
+      node.add_child(self)
+    end
+  end
+
   # like Node but with a reference to its parent
   class ChildNode < Node
     attr_accessor :parent
 
-    def initialize(value)
+    def initialize(value, children: [])
       @parent = nil
-      super(value)
+      super(value, children: children)
     end
 
     # O(log n) recursive
@@ -53,15 +82,33 @@ module CompSci
       @parent ? @parent.children : []
     end
 
+    def set_child(idx, node)
+      node.parent ||= self
+      raise "node has a parent: #{node.parent}" if node.parent != self
+      @children[idx] = node
+    end
+
+    def set_parent(idx, node)
+      @parent = node
+      @parent.set_child(idx, self)
+    end
+  end
+
+  # ChildNode which accumulates children with no gaps
+  class ChildFlexNode < ChildNode
     def add_child(node)
       node.parent ||= self
       raise "node has a parent: #{node.parent}" if node.parent != self
-      super(node)
+      @children << node
+    end
+
+    def new_child(value)
+      self.add_child self.class.new(value)
     end
 
     def add_parent(node)
       @parent = node
-      super(node)
+      @parent.add_child(self)
     end
   end
 end

data/lib/compsci/simplex.rb

@@ -0,0 +1,173 @@
+require 'compsci'
+
+# note, this work is based on https://github.com/rickhull/simplex
+# which was forked in 2017 from https://github.com/danlucraft/simplex
+# which had its last commit in 2013
+
+class CompSci::Simplex
+  DEFAULT_MAX_PIVOTS = 10_000
+
+  class Error < RuntimeError; end
+  class UnboundedProblem < Error; end
+  class SanityCheck < Error; end
+  class TooManyPivots < Error; end
+
+  attr_accessor :max_pivots
+
+  # c - coefficients of objective function; size: num_vars
+  # a - inequality lhs coefficients;   2dim size: num_inequalities, num_vars
+  # b - inequality rhs constants            size: num_inequalities
+  def initialize(c, a, b)
+    num_vars = c.size
+    num_inequalities = b.size
+    raise(ArgumentError, "a doesn't match b") unless a.size == num_inequalities
+    raise(ArgumentError, "a doesn't match c") unless a.first.size == num_vars
+
+    @max_pivots = DEFAULT_MAX_PIVOTS
+
+    # Problem dimensions; these never change
+    @num_non_slack_vars = num_vars
+    @num_constraints    = num_inequalities
+    @num_vars           = @num_non_slack_vars + @num_constraints
+
+    # Set up initial matrix A and vectors b, c
+    @c = c.map { |flt| -1 * flt } + Array.new(@num_constraints, 0)
+    @a = a.map.with_index { |ary, i|
+      if ary.size != @num_non_slack_vars
+        raise ArgumentError, "a is inconsistent"
+      end
+      # set diagonal to 1 (identity matrix?)
+      ary + Array.new(@num_constraints) { |ci| ci == i ? 1 : 0 }
+    }
+    @b = b
+
+    # set initial solution: all non-slack variables = 0
+    @basic_vars = (@num_non_slack_vars...@num_vars).to_a
+    self.update_solution
+  end
+
+  # does not modify vector / matrix
+  def update_solution
+    @x = Array.new(@num_vars, 0)
+
+    @basic_vars.each { |basic_var|
+      idx = nil
+      @num_constraints.times { |i|
+        if @a[i][basic_var] == 1
+          idx =i
+          break
+        end
+      }
+      raise(SanityCheck, "no idx for basic_var #{basic_var} in a") unless idx
+      @x[basic_var] = @b[idx]
+    }
+  end
+
+  def solution
+    self.solve
+    self.current_solution
+  end
+
+  def solve
+    count = 0
+    while self.can_improve?
+      count += 1
+      raise(TooManyPivots, count.to_s) unless count < @max_pivots
+      self.pivot
+    end
+  end
+
+  def current_solution
+    @x[0...@num_non_slack_vars]
+  end
+
+  def can_improve?
+    !self.entering_variable.nil?
+  end
+
+  # idx of @c's minimum negative value
+  # nil when no improvement is possible
+  #
+  def entering_variable
+    (0...@c.size).select { |i| @c[i] < 0 }.min_by { |i| @c[i] }
+  end
+
+  def pivot
+    pivot_column = self.entering_variable or return nil
+    pivot_row = self.pivot_row(pivot_column) or raise UnboundedProblem
+    leaving_var = nil
+    @a[pivot_row].each_with_index { |a, i|
+      if a == 1 and @basic_vars.include?(i)
+        leaving_var = i
+        break
+      end
+    }
+    raise(SanityCheck, "no leaving_var") if leaving_var.nil?
+
+    @basic_vars.delete(leaving_var)
+    @basic_vars.push(pivot_column)
+    @basic_vars.sort!
+
+    pivot_ratio = Rational(1, @a[pivot_row][pivot_column])
+
+    # update pivot row
+    @a[pivot_row] = @a[pivot_row].map { |val| val * pivot_ratio }
+    @b[pivot_row] = @b[pivot_row] * pivot_ratio
+
+    # update objective
+    # @c -= @c[pivot_column] * @a[pivot_row]
+    @c = @c.map.with_index { |val, i|
+      val - @c[pivot_column] * @a[pivot_row][i]
+    }
+
+    # update A and B
+    @num_constraints.times { |i|
+      next if i == pivot_row
+      r = @a[i][pivot_column]
+      @a[i] = @a[i].map.with_index { |val, j| val - r * @a[pivot_row][j] }
+      @b[i] = @b[i] - r * @b[pivot_row]
+    }
+
+    self.update_solution
+  end
+
+  def pivot_row(column_ix)
+    min_ratio = nil
+    idx = nil
+    @num_constraints.times { |i|
+      a, b = @a[i][column_ix], @b[i]
+      next if a == 0 or (b < 0) ^ (a < 0)
+      ratio = Rational(b, a)
+      idx, min_ratio = i, ratio if min_ratio.nil? or ratio <= min_ratio
+    }
+    idx
+  end
+
+  def formatted_tableau
+    if self.can_improve?
+      pivot_column = self.entering_variable
+      pivot_row    = self.pivot_row(pivot_column)
+    else
+      pivot_row = nil
+    end
+    c = @c.to_a.map { |flt| "%2.3f" % flt }
+    b = @b.to_a.map { |flt| "%2.3f" % flt }
+    a = @a.to_a.map { |vec| vec.to_a.map { |flt| "%2.3f" % flt } }
+    if pivot_row
+      a[pivot_row][pivot_column] = "*" + a[pivot_row][pivot_column]
+    end
+    max = (c + b + a + ["1234567"]).flatten.map(&:size).max
+    result = []
+    result << c.map { |str| str.rjust(max, " ") }
+    a.zip(b) do |arow, brow|
+      result << (arow + [brow]).map { |val| val.rjust(max, " ") }
+      result.last.insert(arow.length, "|")
+    end
+    lines = result.map { |ary| ary.join("  ") }
+    max_line_length = lines.map(&:length).max
+    lines.insert(1, "-"*max_line_length)
+    lines.join("\n")
+  end
+
+
+end

data/lib/compsci/simplex/parse.rb

@@ -0,0 +1,125 @@
+require 'compsci/simplex'
+
+class CompSci::Simplex
+  module Parse
+    class Error < RuntimeError; end
+    class InvalidExpression < Error; end
+    class InvalidInequality < Error; end
+    class InvalidTerm < Error; end
+
+    # coefficient concatenated with a single letter variable, e.g. "-1.23x"
+    TERM_RGX = %r{
+      \A                  # starts with
+        (-)?              # possible negative sign
+        (\d+(?:\.\d*)?)?  # possible float (optional)
+        ([a-zA-Z])        # single letter variable
+      \z                  # end str
+    }x
+
+    # a float or integer, possibly negative
+    CONSTANT_RGX = %r{
+      \A           # starts with
+        -?         # possible negative sign
+        \d+        # integer portion
+        (?:\.\d*)? # possible decimal portion
+      \z           # end str
+    }x
+
+    def self.inequality(str)
+      lhs, rhs = str.split('<=')
+      if lhs.nil? or lhs.empty? or rhs.nil? or rhs.empty?
+        raise(InvalidInequality, "#{str}")
+      end
+      rht = self.tokenize(rhs)
+      raise(InvalidInequality, "#{str}; bad rhs: #{rhs}") unless rht.size == 1
+      c = rht.first
+      raise(InvalidInequality, "bad rhs: #{rhs}") if !c.match CONSTANT_RGX
+      return self.expression(lhs), c.to_f
+    end
+
+    # ignore leading and trailing spaces
+    # ignore multiple spaces
+    def self.tokenize(str)
+      str.strip.split(/\s+/)
+    end
+
+    # rules: variables are a single letter
+    #        may have a coefficient (default: 1.0)
+    #        only sum and difference operations allowed
+    #        normalize to all sums with possibly negative coefficients
+    # valid inputs:
+    #   'x + y'          => [1.0, 1.0],         [:x, :y]
+    #   '2x - 5y'        => [2.0, -5.0],        [:x, :y]
+    #   '-2x - 3y + -4z' => [-2.0, -3.0, -4.0], [:x, :y, :z]
+    def self.expression(str)
+      terms = self.tokenize(str)
+      negative = false
+      coefficients = {}
+      while !terms.empty?
+        # consume plus and minus operations
+        term = terms.shift
+        if term == '-'
+          negative = true
+          term = terms.shift
+        elsif term == '+'
+          negative = false
+          term = terms.shift
+        end
+
+        coefficient, variable = self.term(term)
+        raise("double variable: #{str}") if coefficients.key?(variable)
+        coefficients[variable] = negative ? coefficient * -1 : coefficient
+      end
+      coefficients
+    end
+
+    def self.term(str)
+      matches = str.match TERM_RGX
+      raise(InvalidTerm, str) unless matches
+      flt = (matches[2] || 1).to_f * (matches[1] ? -1 : 1)
+      sym = matches[3].to_sym # consider matches[3].downcase.to_sym
+      return flt, sym
+    end
+  end
+
+  def self.problem(maximize: nil, constraints: [], **kwargs)
+    if maximize
+      obj, maximize = maximize, true
+    elsif kwargs[:minimize]
+      obj, maximize = kwargs[:minimize], false
+    else
+      raise(ArgumentError, "one of maximize/minimize expected")
+    end
+    unless obj.is_a?(String)
+      raise(ArgumentError, "bad expr: #{expr} (#{expr.class})")
+    end
+    obj_cof = Parse.expression(obj)
+
+    c = [] # coefficients of objective expression
+    a = [] # array (per constraint) of the inequality's lhs coefficients
+    b = [] # rhs (constant) for the inequalities / constraints
+
+    # this determines the order of coefficients
+    letter_vars = obj_cof.keys
+    letter_vars.each { |v| c << obj_cof[v] }
+
+    constraints.each { |str|
+      unless str.is_a?(String)
+        raise(ArgumentError, "bad constraint: #{str} (#{str.class})")
+      end
+      cofs = []
+      ineq_cofs, rhs = Parse.inequality(str)
+      letter_vars.each { |v|
+        raise("constraint #{str} is missing var #{v}") unless ineq_cofs.key?(v)
+        cofs << ineq_cofs[v]
+      }
+      a.push cofs
+      b.push rhs
+    }
+    self.new(c, a, b)
+  end
+
+  def self.maximize(expression, *ineqs)
+    self.problem(maximize: expression, constraints: ineqs).solution
+  end
+end