add latex support for transportation

CHANGELOG.md

@@ -1,5 +1,6 @@
 ### 0.1.6 (Upcoming release) 
 
+- Add Latex support for Transportation tables
 - Pretty printing simplex iterations
 - Automatic calculation of objective value by iterations and manual calculation code is removed
 

docs/make.jl

@@ -1,19 +1,15 @@
 using Documenter, OperationsResearchModels
 
 makedocs(
-         format = Documenter.HTML(
-                                  prettyurls = get(ENV, "CI", nothing) == "true",
-                                  collapselevel = 2,
-                                  # assets = ["assets/favicon.ico", "assets/extra_styles.css"],
-                                 ),
-         sitename="OperationsResearchModels.jl",
-         authors = "Mehmet Hakan Satman",
-         pages = [
-                  "Algorithms" => "algorithms.md"
-                 ]
-        )
+    format = Documenter.HTML(
+        prettyurls = get(ENV, "CI", nothing) == "true",
+        collapselevel = 2,
+        # assets = ["assets/favicon.ico", "assets/extra_styles.css"],
+    ),
+    sitename = "OperationsResearchModels.jl",
+    authors = "Mehmet Hakan Satman",
+    pages = ["Algorithms" => "algorithms.md"],
+)
 
 
-deploydocs(
-           repo = "github.com/jbytecode/OperationsResearchModels.jl",
-          )
+deploydocs(repo = "github.com/jbytecode/OperationsResearchModels.jl")

src/OperationsResearchModels.jl

@@ -6,6 +6,7 @@ using HiGHS
 const theoptimizerpackage = Symbol("HiGHS")
 const theoptimizer = HiGHS.Optimizer
 
+include("utility.jl")
 include("network.jl")
 include("transportation.jl")
 include("assignment.jl")
@@ -16,6 +17,7 @@ include("mst.jl")
 include("pmedian.jl")
 include("cpm.jl")
 include("simplex.jl")
+include("latex.jl")
 
 import .Network
 import .Transportation
@@ -26,9 +28,12 @@ import .Game
 import .MinimumSpanningTree
 import .PMedian
 import .CPM
-import .Simplex 
+import .Simplex
+import .Latex
+import .Utility
 
-import .Transportation: TransportationProblem, TransportationResult, balance, isbalanced, northwestcorner
+import .Transportation:
+    TransportationProblem, TransportationResult, balance, isbalanced, northwestcorner
 import .ShortestPath: ShortestPathResult
 import .Network: Connection, ShortestPathProblem, MaximumFlowProblem, nodes
 import .MaximumFlow: MaximumFlowResult
@@ -38,6 +43,7 @@ import .MinimumSpanningTree: hasloop, mst, MstResult
 import .PMedian: pmedian
 import .CPM: cpm, CpmActivity, earliestfinishtime, longestactivity, CpmResult
 import .CPM: pert, PertActivity, PertResult
+import .Latex: latex
 
 export TransportationProblem, TransportationResult, balance, isbalanced, northwestcorner
 export Connection, ShortestPathResult, MaximumFlowResult, nodes
@@ -49,6 +55,8 @@ export pmedian
 export cpm, CpmActivity, earliestfinishtime, longestactivity, CpmResult
 export pert, PertActivity, PertResult
 export Simplex
+export Utility
+export latex
 
 """
     solve(t)
@@ -143,7 +151,10 @@ solve(a::AssignmentProblem) = Assignment.solve(a)
 
 
 
-function solve(c::Vector{Connection}; problem::Union{Type{ShortestPathProblem},Type{MaximumFlowProblem}}=ShortestPathProblem)
+function solve(
+    c::Vector{Connection};
+    problem::Union{Type{ShortestPathProblem},Type{MaximumFlowProblem}} = ShortestPathProblem,
+)
     if problem == ShortestPathProblem
         return ShortestPath.solve(c)
     elseif problem == MaximumFlowProblem

src/assignment.jl

@@ -2,45 +2,41 @@ module Assignment
 
 using JuMP, HiGHS
 
-struct AssignmentProblem{T <: Real}
-    costs  :: Array{T, 2}
+struct AssignmentProblem{T<:Real}
+    costs::Array{T,2}
 end
 
-struct AssignmentResult 
-    problem :: AssignmentProblem
-    solution :: Matrix
-    cost :: Real
-end 
+struct AssignmentResult
+    problem::AssignmentProblem
+    solution::Matrix
+    cost::Real
+end
 
 
 function solve(a::AssignmentProblem)::AssignmentResult
     model = JuMP.Model(HiGHS.Optimizer)
     MOI.set(model, MOI.Silent(), true)
-    
+
     n, p = size(a.costs)
     @assert n == p
 
     @variable(model, x[1:n, 1:p], Bin)
     @objective(model, Min, sum(a.costs .* x))
 
-    @constraint(model, sum(x[1:n, j] for j in 1:p) .== 1.0)
-    @constraint(model, sum(x[i, 1:p] for i in 1:n) .== 1.0)
-    
+    @constraint(model, sum(x[1:n, j] for j = 1:p) .== 1.0)
+    @constraint(model, sum(x[i, 1:p] for i = 1:n) .== 1.0)
+
     optimize!(model)
-    
-    solution =  value.(x)
+
+    solution = value.(x)
     cost = JuMP.objective_value(model)
 
-    result = AssignmentResult(
-        a,
-        solution, 
-        cost
-    )
-    return result 
+    result = AssignmentResult(a, solution, cost)
+    return result
 end
 
-export solve 
+export solve
 export AssignmentProblem
 export AssignmentResult
 
-end # end of module 
+end # end of module 

src/cpm.jl

@@ -1,6 +1,6 @@
-module CPM 
+module CPM
 
-export cpm 
+export cpm
 export CpmActivity
 export CpmResult
 export earliestfinishtime
@@ -9,38 +9,38 @@ export PertActivity
 export PertResult
 export pert
 
-struct CpmActivity 
-    name::String 
-    time::Float64 
+struct CpmActivity
+    name::String
+    time::Float64
     dependencies::Vector{CpmActivity}
-end 
+end
 
-struct CpmResult 
+struct CpmResult
     pathstr::Vector{String}
     path::Vector{CpmActivity}
-end 
+end
 
-struct PertActivity 
-    name::String 
-    optimistic::Float64 
-    mostlikely::Float64 
-    pessimistic::Float64 
+struct PertActivity
+    name::String
+    optimistic::Float64
+    mostlikely::Float64
+    pessimistic::Float64
     dependencies::Vector{PertActivity}
 end
 
-struct PertResult 
+struct PertResult
     path::Vector{PertActivity}
     mean::Float64
-    stddev::Float64 
+    stddev::Float64
 end
 
-function CpmActivity(name::String, time::T)::CpmActivity where {T <: Real}
+function CpmActivity(name::String, time::T)::CpmActivity where {T<:Real}
     return CpmActivity(name, Float64(time), CpmActivity[])
-end 
+end
 
-function PertActivity(name::String, o::T, m::T, p::T)::PertActivity where {T <: Real}
+function PertActivity(name::String, o::T, m::T, p::T)::PertActivity where {T<:Real}
     return PertActivity(name, Float64(o), Float64(m), Float64(p), PertActivity[])
-end 
+end
 
 
 
@@ -50,40 +50,40 @@ function earliestfinishtime(activity::CpmActivity)
 
     if L == 0
         return activity.time
-    end 
+    end
 
     v = Float64[]
 
-    for i in 1:L
+    for i = 1:L
         push!(v, earliestfinishtime(activity.dependencies[i]))
-    end  
+    end
 
     return maximum(v) + activity.time
-end 
+end
 
 function longestactivity(activies::Vector{CpmActivity})::CpmActivity
     activity = CpmActivity("", -1, CpmActivity[])
     maxval = typemin(Float64)
 
     for a in activies
         ea = earliestfinishtime(a)
-        if ea > maxval 
-            maxval = ea 
-            activity = a 
-        end 
-    end 
-    
-    return activity 
-end 
+        if ea > maxval
+            maxval = ea
+            activity = a
+        end
+    end
+
+    return activity
+end
 
 function pathtostring(activities::Vector{CpmActivity})::Vector{String}
     L = length(activities)
     v = String[]
-    for i in 1:L 
+    for i = 1:L
         push!(v, activities[i].name)
     end
     return reverse(v)
-end 
+end
 
 """
     cpm(activities)
@@ -131,24 +131,24 @@ function cpm(activities::Vector{CpmActivity})::CpmResult
     while true
         longest = longestactivity(activities)
         push!(path, longest)
-        if length(longest.dependencies) == 0 
+        if length(longest.dependencies) == 0
             break
         end
         activities = longest.dependencies
     end
 
     return CpmResult(pathtostring(path), reverse(path))
-end 
+end
 
-function mean(a::PertActivity)::Float64 
+function mean(a::PertActivity)::Float64
     return (a.optimistic + 4.0 * a.mostlikely + a.pessimistic) / 6.0
-end 
+end
 
-function var(a::PertActivity)::Float64 
-    return ((a.pessimistic - a.optimistic) / 6.0) ^ 2.0
-end 
+function var(a::PertActivity)::Float64
+    return ((a.pessimistic - a.optimistic) / 6.0)^2.0
+end
 
-function Base.sum(activities::Vector{CpmActivity})::Float64 
+function Base.sum(activities::Vector{CpmActivity})::Float64
     return sum([x.time for x in activities])
 end
 
@@ -157,20 +157,23 @@ function var(as::Vector{PertActivity})::Float64
 end
 
 
-function findpertactivities(cpmpath::Vector{CpmActivity}, pertactivities::Vector{PertActivity})
+function findpertactivities(
+    cpmpath::Vector{CpmActivity},
+    pertactivities::Vector{PertActivity},
+)
     L = length(cpmpath)
-    perts = Array{PertActivity, 1}(undef, L)
-    for i in 1:L
+    perts = Array{PertActivity,1}(undef, L)
+    for i = 1:L
         currentcpmactivity = cpmpath[i]
         pertactivity = filter(x -> x.name == currentcpmactivity.name, pertactivities)[1]
         perts[i] = pertactivity
-    end 
+    end
     return perts
 end
 
 function perttocpm(a::PertActivity)::CpmActivity
     return CpmActivity(a.name, mean(a), perttocpm.(a.dependencies))
-end 
+end
 
 
 
@@ -209,23 +212,20 @@ julia> result.stddev
 """
 function pert(activities::Vector{PertActivity})
     L = length(activities)
-    cpmactivities = Array{CpmActivity, 1}(undef, L)
-    for i in 1:L
+    cpmactivities = Array{CpmActivity,1}(undef, L)
+    for i = 1:L
         current::PertActivity = activities[i]
-        cpmactivity = CpmActivity(current.name, mean(current), perttocpm.(current.dependencies))
+        cpmactivity =
+            CpmActivity(current.name, mean(current), perttocpm.(current.dependencies))
         cpmactivities[i] = cpmactivity
     end
     cpmresult = cpm(cpmactivities)
     pertpath = cpmresult.path
     pertactivities = findpertactivities(pertpath, activities)
     pertmean = sum(pertpath)
     stddev = sqrt(var(pertactivities))
-
-    return PertResult(
-        pertactivities,
-        pertmean,
-        stddev
-    )
+
+    return PertResult(pertactivities, pertmean, stddev)
 end
 
-end # end of module Project 
+end # end of module Project