simplex 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5431fa9728f8db469cb36abb63ac55a373034f54
-  data.tar.gz: a742fe78724dba49f9611a6fadcabe6f0167e81c
+  metadata.gz: 653a4166c7a16f592147416d42e2a9e69aebc01d
+  data.tar.gz: a023d7fd81dd5bb510ae19c6508415fdc9ab9935
 SHA512:
-  metadata.gz: ac3edb3eaeda1411bec67c29f2a556d67ad14dee695e76a0c5470733b0611094665d1cbc2799b25a6a7e51a0f20d4a9c7ef2562893767054fe059c325c0b2143
-  data.tar.gz: e63deec02516c54b58bef985fafd584ade2003815d7c2b4201837459eedd82408b112e8c9e7f4b3397aeb7940ac1357cfbb508cfb549c7b5e3b52353ac1ac9e1
+  metadata.gz: df013865a60100ab6056ef9df8699e2f729aa8e9778650fc33e401cfddcf3100307548c72d273c606f37ea1d7b7e7b463f6d347dd279a7bc31999cabd69633de
+  data.tar.gz: 9e77d9f2623751bd64c8370b1477c9cce6bc54a8ee7adb2a9c506935db613f4d1fe68108ef0c227772acc78ff8455c70ba5d4786a088cd16bb16102954b0ebed

data/README.md

@@ -2,6 +2,8 @@
 simplex
 =======
 
+[![Build Status](https://travis-ci.org/danlucraft/simplex.png)](https://travis-ci.org/danlucraft/simplex)
+
 A naive pure-Ruby implementation of the Simplex algorithm for solving linear programming problems. Solves maximizations in standard form.
 
 ### Why?

data/lib/simplex.rb

@@ -1,143 +1,182 @@
 require 'matrix'
 
-class Matrix
-  def []=(i, j, x)
-    @rows[i][j] = x
-  end
-end
-
 class Vector
   public :[]=
 end
 
 class Simplex
-  DEFAULT_MAX_ITERATIONS = 10_000
+  DEFAULT_MAX_PIVOTS = 10_000
 
-  attr_accessor :max_iterations
+  attr_accessor :max_pivots
 
   def initialize(c, a, b)
-    @max_iterations = DEFAULT_MAX_ITERATIONS
+    @pivot_count = 0
+    @max_pivots = DEFAULT_MAX_PIVOTS
+
     # Problem dimensions
     @num_non_slack_vars = a.first.length
     @num_constraints    = b.length
     @num_vars           = @num_non_slack_vars + @num_constraints
-    @x                  = Array.new(@num_vars)
 
     # Set up initial matrix A and vectors b, c
     @c = Vector[*c.map {|c1| -1*c1 } + [0]*@num_constraints]
-    @a = Matrix[*a.map {|a1| a1.clone + [0]*@num_constraints}]
+    @a = a.map {|a1| Vector[*(a1.clone + [0]*@num_constraints)]}
     @b = Vector[*b.clone]
-    0.upto(@num_constraints - 1) {|i| @a[i, @num_non_slack_vars + i] = 1 }
 
-    @basic_vars = ((@num_non_slack_vars)...(@num_vars)).to_a
+    unless @a.all? {|a| a.size == @c.size } and @b.size == @a.length
+      raise ArgumentError, "Input arrays have mismatched dimensions" 
+    end
+
+    0.upto(@num_constraints - 1) {|i| @a[i][@num_non_slack_vars + i] = 1 }
 
     # set initial solution: all non-slack variables = 0
+    @x          = Vector[*([0]*@num_vars)]
+    @basic_vars = (@num_non_slack_vars...@num_vars).to_a
     update_solution
-    @solved = false
   end
 
-  def solve
-    return if @solved
-    i = 0
-    while can_improve?
-      i += 1
-      raise "Too many iterations" if i > max_iterations 
-
-      pivot_column = entering_variable_ix
-      pivot_row    = minimum_coefficient_ratio_row_ix(pivot_column)
-      leaving_var = leaving_variable(pivot_row)
-      @basic_vars.delete(leaving_var)
-
-      # update objective
-      c_ratio = Rational(@c[pivot_column], @a[pivot_row, pivot_column])
-      @c = @c - (@a.row(pivot_row)*c_ratio)
-
-      # update pivot row
-      ratio = Rational(1, @a[pivot_row, pivot_column])
-      0.upto(@a.column_count - 1) do |column_ix|
-        @a[pivot_row, column_ix] = ratio * @a[pivot_row, column_ix]
-      end
-      @b[pivot_row] = ratio * @b[pivot_row]
-
-      # update A and B
-      0.upto(@a.row_count - 1) do |row_ix|
-        next if row_ix == pivot_row
-        ratio = @a[row_ix, pivot_column]
-        0.upto(@a.column_count - 1) do |column_ix|
-          @a[row_ix, column_ix] = @a[row_ix, column_ix] - ratio*@a[pivot_row, column_ix]
-        end
-        @b[row_ix] = @b[row_ix] - ratio*@b[pivot_row]
-      end
+  def solution
+    solve
+    current_solution
+  end
 
-      @basic_vars << pivot_column
-      @basic_vars.sort!
-      update_solution
-    end
-    @solved = true
+  def current_solution
+    @x.to_a[0...@num_non_slack_vars]
   end
 
   def update_solution
     0.upto(@num_vars - 1) {|i| @x[i] = 0 }
+
     @basic_vars.each do |basic_var|
-      row_coeff_1 = nil
-      0.upto(@a.row_count - 1) do |row_ix|
-        coeff = @a[row_ix, basic_var]
-        if coeff == 1
-          if row_coeff_1 == nil
-            row_coeff_1 = row_ix
-          end
-        end
+      row_with_1 = row_indices.detect do |row_ix|
+        @a[row_ix][basic_var] == 1
       end
-      @x[basic_var] = @b[row_coeff_1]
+      @x[basic_var] = @b[row_with_1]
     end
   end
 
-  def solution
-    solve
-    @x.to_a[0...@num_non_slack_vars]
+  def solve
+    while can_improve?
+      @pivot_count += 1
+      raise "Too many pivots" if @pivot_count > max_pivots 
+      pivot
+    end
   end
 
   def can_improve?
-    !!entering_variable_ix
-  end
-
-  def entering_variable_ix
-    current_min_value = nil
-    current_min_index = nil
-    @c.each_with_index do |v, i| 
-      if v < 0
-        if current_min_value == nil || v < current_min_value
-          current_min_value = v
-          current_min_index = i
-        end
-      end
+    !!entering_variable
+  end
+
+  def variables
+    (0...@c.size).to_a
+  end
+
+  def entering_variable
+    variables.select { |var| @c[var] < 0 }.
+              min_by { |var| @c[var] }
+  end
+
+  def pivot
+    pivot_column = entering_variable
+    pivot_row    = pivot_row(pivot_column)
+    leaving_var  = basic_variable_in_row(pivot_row)
+    replace_basic_variable(leaving_var => pivot_column)
+
+    pivot_ratio = Rational(1, @a[pivot_row][pivot_column])
+
+    # update pivot row
+    @a[pivot_row] *= pivot_ratio
+    @b[pivot_row] = pivot_ratio * @b[pivot_row]
+
+    # update objective
+    @c -= @c[pivot_column] * @a[pivot_row]
+
+    # update A and B
+    (row_indices - [pivot_row]).each do |row_ix|
+      r = @a[row_ix][pivot_column]
+      @a[row_ix] -= r * @a[pivot_row]
+      @b[row_ix] -= r * @b[pivot_row]
     end
-    current_min_index
+
+    update_solution
   end
 
-  def leaving_variable(pivot_row)
-    0.upto(@a.column_count - 1) do |column_ix|
-      if @a[pivot_row, column_ix] == 1 and @basic_vars.include?(column_ix)
-        return column_ix
-      end
+  def replace_basic_variable(hash)
+    from, to = hash.keys.first, hash.values.first
+    @basic_vars.delete(from)
+    @basic_vars << to
+    @basic_vars.sort!
+  end
+
+  def pivot_row(column_ix)
+    row_ix_a_and_b = row_indices.map { |row_ix|
+      [row_ix, @a[row_ix][column_ix], @b[row_ix]]
+    }.reject { |_, a, b|
+      a == 0
+    }.reject { |_, a, b|
+      (b < 0 or a < 0) and !(b < 0 and a < 0)  # negative sign check
+    }
+    row_ix, _, _ = *last_min_by(row_ix_a_and_b) { |_, a, b|
+      Rational(b, a)
+    }
+    row_ix
+  end
+
+  def basic_variable_in_row(pivot_row)
+    column_indices.detect do |column_ix|
+      @a[pivot_row][column_ix] == 1 and @basic_vars.include?(column_ix)
     end
   end
 
-  def minimum_coefficient_ratio_row_ix(column_ix)
-    current_min_value = nil
-    current_min_index = nil
-    0.upto(@a.row_count - 1) do |row_ix|
-      next if @a[row_ix, column_ix] == 0
-      b_val = @b[row_ix]
-      a_val = @a[row_ix, column_ix]
-      ratio = Rational(b_val, a_val)
-      is_negative = (@b[row_ix] < 0 || @a[row_ix, column_ix] < 0) && !(@b[row_ix] < 0 && @a[row_ix, column_ix] < 0)
-      if !is_negative && (!current_min_value || ratio <= current_min_value)
-        current_min_value = ratio
-        current_min_index = row_ix
+  def row_indices
+    (0...@a.length).to_a
+  end
+
+  def column_indices
+    (0...@a.first.size).to_a
+  end
+
+  def formatted_tableau
+    pivot_column = entering_variable
+    pivot_row    = pivot_row(pivot_column)
+    num_cols = @c.size + 1
+    c = formatted_values(@c.to_a)
+    b = formatted_values(@b.to_a)
+    a = @a.to_a.map {|ar| formatted_values(ar.to_a) }
+    a[pivot_row][pivot_column] = "*" + a[pivot_row][pivot_column]
+    max = (c + b + a + ["1234567"]).flatten.map(&:size).max
+    result = []
+    result << c.map {|c| c.rjust(max, " ") }
+    a.zip(b) do |arow, brow|
+      result << (arow + [brow]).map {|a| a.rjust(max, " ") }
+      result.last.insert(arow.length, "|")
+    end
+    lines = result.map {|b| b.join("  ") }
+    max_line_length = lines.map(&:length).max
+    lines.insert(1, "-"*max_line_length)
+    lines.join("\n")
+  end
+
+  def formatted_values(array)
+    array.map {|c| "%2.3f" % c }
+  end
+
+  # like Enumerable#min_by except if multiple values are minimum 
+  # it returns the last
+  def last_min_by(array)
+    best_element, best_value = nil, nil
+    array.each do |element|
+      value = yield element
+      if !best_element || value <= best_value
+        best_element, best_value = element, value
       end
     end
-    return current_min_index
+    best_element
   end
+
+  def assert(boolean)
+    raise unless boolean
+  end
+
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simplex
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Daniel Lucraft
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-17 00:00:00.000000000 Z
+date: 2013-12-20 00:00:00.000000000 Z
 dependencies: []
 description: Naive implementation of the simplex linear programming algorithm in pure
   Ruby.
@@ -31,7 +31,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
@@ -39,7 +39,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Simplex linear programming solver