Colors and new pivoting

Author: scheinerman

Project.toml

@@ -1,11 +1,12 @@
 name = "SimplexTableaux"
 uuid = "b49aa546-d643-4829-bb91-bc1e5e539d80"
 authors = ["Ed Scheinerman <ers@jhu.edu>"]
-version = "0.0.4"
+version = "0.0.5"
 
 [deps]
 ChooseOptimizer = "858a232f-1959-5553-8cfc-91e1fd5304e2"
 Combinatorics = "861a8166-3701-5b0c-9a16-15d98fcdc6aa"
+Crayons = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f"
 JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
 LatexPrint = "d2208f48-c256-5759-9089-c25ed2a93924"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -16,6 +17,7 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 [compat]
 ChooseOptimizer = "0.3"
 Combinatorics = "1"
+Crayons = "4"
 JuMP = "1"
 LatexPrint = "1"
 LinearAlgebra = "1"

src/LPsolve.jl

@@ -26,8 +26,6 @@ function lp_solve(T::Tableau, verbose::Bool=true)
         println("Optimum value = $obj_val\n")
     end
 
-    @show x 
-
     xval = JuMP.value.(x)
 
     return xval

src/Pivoting.jl

@@ -2,12 +2,12 @@ _not_row_one = "May not modify the header row of the Tableau"
 _not_col_one = "May not modify the z column of the Tableau"
 
 """
-    pivot!(T::Tableau, i::Int, j::Int)
+    old_pivot!(T::Tableau, i::Int, j::Int)
 
 Modify `T` by doing a pivot operation at contraint `i` 
 and variable x_`j`.
 """
-function pivot!(T::Tableau, i::Int, j::Int)
+function old_pivot!(T::Tableau, i::Int, j::Int)
     M = T.M  # for easier access
 
     i += 1
@@ -29,108 +29,76 @@ function pivot!(T::Tableau, i::Int, j::Int)
 end
 
 """
-    pivot(T::Tableau, i::Int, j::Int)
+    set_basis!(T::Tableau, vars::Vector{Int})
 
-Non-modifying version of `pivot!`.
+Pivot `T` so that the variables specified in `vars`
+are the basic variables. 
 """
-function pivot(T::Tableau, i::Int, j::Int)
-    TT = deepcopy(T)
-    return pivot!(TT, i, j)
-end
+function set_basis!(T::Tableau, vars::Vector{Int})
+    n = T.n_vars
+    m = T.n_cons
 
-"""
-    scale!(T::Tableau, r::Int, s::_Exact)
+    vars = sort(unique(vars))
 
-Multiply row `r` of `T` by `s` (which must be nonzero).
-"""
-function scale!(T::Tableau, r::Int, s::_Exact)
-    r += 1
-    if r==1
-        error(_not_row_one)
-    end
-    if s == 0
-        error("May not scale by 0")
+    if (length(vars) ≠ m) || !(vars ⊆ collect(1:n))
+        error("Invalid basis: $vars")
     end
-    T.M[r, :] *= s
-    return T
-end
 
-"""
-    scale(T::Tableau, r::Int, s::_Exact)
+    # bop up indices by 1 and make a list
+    idx = [j+1 for j in vars]
+    idx = vcat(1, idx)
 
-Non-modifying version of 
-"""
-function scale(T::Tableau, r::Int, s::_Exact)
-    TT = deepcopy(T)
-    scale!(TT, r, s)
-    return TT
+    B = T.M[:, idx]
+    BB = invx(B)  # will fail if B is not invertible
+    T.M = BB*T.M
+    T.B = vars
+    return T
 end
 
 """
-    swap!(T::Tableau, i::Int, j::Int)
+    get_basis(T::Tableau)
 
-Swap constraints `i` and `j` of the Tableau.
+Return the current basis (indices of basic variables).
 """
-function swap!(T::Tableau, i::Int, j::Int)
-    i += 1
-    j += 1
-    if i<2 || j<2
-        error(_not_row_one)
-    end
-
-    if i==j
-        return T
-    end
-
-    row_i = T.M[i, :]
-    row_j = T.M[j, :]
+get_basis(T::Tableau) = copy(T.B)
 
-    T.M[j, :] = row_i
-    T.M[i, :] = row_j
-
-    T
-end
 """
-    swap(T::Tableau, i::Int, j::Int)
+    pivot!(T::Tableau, leave::Int, enter::Int)
 
-Non-modifying version of `swap!`.
+Remove element `leave` from the basis and include element `enter`.
 """
-function swap(T::Tableau, i::Int, j::Int)
-    TT = deepcopy(T)
-    swap!(TT, i, j)
-end
+function pivot!(T::Tableau, leave::Int, enter::Int)
+    B = Set(get_basis(T))
 
-"""
-    basis_pivot!(T::Tableau, vars)
+    # check for validity
+    if 0 ∈ B
+        error("No basis has been established for this tableau")
+    end
 
-Pivot `T` so that the variables specified in `vars`
-are the basic variables. 
-"""
-function basis_pivot!(T::Tableau, vars)
-    # bop up indices by 1 and make a list
-    idx = [j+1 for j in vars]
-    idx = vcat(1, idx)
+    n = T.n_vars
+    if !(1 ≤ leave ≤ n)
+        error("Invalid variable index: $leave")
+    end
 
-    B = T.M[:, idx]
-    BB = invx(B)  # will fail if B is not invertible
-    new_M = BB*T.M
+    if !(1 ≤ enter ≤ n)
+        error("Invalid variable index: $enter")
+    end
 
-    r, c = size(T.M)
-    for i in 1:r
-        for j in 1:c
-            T.M[i, j] = new_M[i, j]
-        end
+    if leave == enter
+        @warn "No pivot: enter = leave = $enter"
+        return nothing
     end
-    return T
-end
 
-"""
-    basis_pivot(T::Tableau, vars)
+    # form new basis
+    B = Set(get_basis(T))
+    if leave ∉ B
+        error("Element $leave is not in the basis; cannot remove it")
+    end
+    if enter ∈ B
+        error("Element $enter is already in the basis; cannot add it")
+    end
 
-Non-modifying version of `basis_pivot!`.
-"""
-function basis_pivot(T::Tableau, vars)
-    TT = deepcopy(T)
-    basis_pivot!(TT, vars)
-    return TT
+    delete!(B, leave)
+    push!(B, enter)
+    set_basis!(T, collect(B))
 end

src/Pretty.jl

@@ -1,5 +1,9 @@
 # output Tableau using PrettyTables
 
+const _yellow = Crayon(; foreground=:yellow)
+const _green = Crayon(; foreground=:green, bold=true)
+const _blue = Crayon(; foreground=:blue)
+
 function _pretty_string(x::_Exact)::String
     if x isa Integer
         return string(x)
@@ -53,8 +57,18 @@ function _left_column(T::Tableau)
     return result
 end
 
+function _header_colors(T::Tableau)
+    result = [Crayon(), Crayon()]
+    for k in 1:T.n_vars
+        col = k ∈ T.B ? _green : Crayon()
+        push!(result, col)
+    end
+    push!(result, Crayon())
+    return result
+end
+
 function show(io::IO, T::Tableau)
     MM = _pretty_string.(T.M[2:end, :])
     MM = hcat(_left_column(T), MM)
-    pretty_table(MM; header=_header(T))
+    pretty_table(MM; header=_header(T), header_crayon=_header_colors(T))
 end

src/SimplexTableaux.jl

@@ -17,21 +17,7 @@ import Base: show
 include("Exact.jl")
 
 export Tableau,
-    basis_pivot,
-    basis_pivot!,
-    get_Abc,
-    is_feasible,
-    lp_solve,
-    pivot,
-    pivot!,
-    restore,
-    restore!,
-    scale,
-    scale!,
-    swap,
-    swap!,
-    value
-
+    set_basis!, get_Abc, get_basis, is_feasible, lp_solve, old_pivot!, restore!, value
 
 include("Tableau.jl")
 include("Pivoting.jl")

src/Solver.jl

@@ -17,7 +17,7 @@ function pivot_solve!(T::Tableau, verbose::Bool=true)
             break
         end
         verbose && println("\nPivot at ($i,$j)\n")
-        pivot!(T, i, j)
+        old_pivot!(T, i, j)
 
         count += 1
         if count > max_pivots

src/Tableau.jl

@@ -12,13 +12,14 @@ Create a `Tableau` data structure for the linear program minimize `c' * x` subje
 
 If matrix and vectors are already in standard form, then use `Tableau(A, b, c, false)`.
 """
-struct Tableau
+mutable struct Tableau
     M::Matrix{_Exact}     # place to hold the entire Tableau
     A::Matrix             # (original) A matrix
     b::Vector             # (original) RHS, b vector
     c::Vector             # (original) objective coefficients, c vector
     n_vars::Int           # number of variables in the LP
     n_cons::Int           # number of constraints in the LP
+    B::Vector{Int}        # current basis (column indices)
 
     function Tableau(A::AbstractMatrix, b::Vector, c::Vector, is_cannonical::Bool=true)
         m, n = size(A)
@@ -40,7 +41,9 @@ struct Tableau
             @warn("Rank difficient Tableau")
         end
 
-        return new(M, A, b, c, n, m)
+        B = zeros(Int, m)  # basis is all 0s to start
+
+        return new(M, A, b, c, n, m, B)
     end
 end
 
@@ -97,6 +100,7 @@ function restore!(T::Tableau)
             T.M[i, j] = TT.M[i, j]
         end
     end
+    T.B = zeros(Int, T.n_cons)
     return T
 end
 
@@ -107,4 +111,4 @@ Return the value of the LP in `T` at the point `x`.
 """
 function value(T::Tableau, x::Vector)
     return T.c' * x
-end
+end