(#2) Apply JuliaFormatter on src

Author: jbytecode

src/OperationsResearchModels.jl

@@ -14,7 +14,7 @@ using JuMP, HiGHS
 # solve(m::MstProblem)::MstResult
 # solve(t::TravelingSalesmanProblem)::TravelingSalesmanResult
 # solve(p::JohnsonProblem)::JohnsonResult
-solve() = nothing 
+solve() = nothing
 
 # solve!(s::SimplexProblem)::SimplexProblem
 solve!() = nothing
@@ -28,10 +28,10 @@ balance() = nothing
 isbalanced() = nothing
 
 
-export solve 
+export solve
 export solve!
 export balance
-export isbalanced 
+export isbalanced
 
 
 include("utility.jl")
@@ -72,10 +72,11 @@ import .TravelingSalesman
 
 
 import .Transportation:
-    TransportationProblem, 
-    TransportationResult, 
-    balance, isbalanced, 
-    northwestcorner, 
+    TransportationProblem,
+    TransportationResult,
+    balance,
+    isbalanced,
+    northwestcorner,
     leastcost
 
 import .ShortestPath: ShortestPathResult, ShortestPathProblem
@@ -94,9 +95,11 @@ import .Latex: latex
 import .Johnsons: JohnsonProblem, JohnsonResult, JohnsonException, makespan, johnsons_ga
 import .RandomKeyGA: Chromosome, run_ga
 import .TravelingSalesman: TravelingSalesmanResult, TravelingSalesmanProblem
-import .Simplex: SimplexProblem, simplexiterations, createsimplexproblem, gaussjordan, OptimizationType
+import .Simplex:
+    SimplexProblem, simplexiterations, createsimplexproblem, gaussjordan, OptimizationType
 
-export TransportationProblem, TransportationResult, balance, isbalanced, northwestcorner, leastcost
+export TransportationProblem,
+    TransportationResult, balance, isbalanced, northwestcorner, leastcost
 export Connection, ShortestPathResult, MaximumFlowResult, MinimumCostFlowResult, nodes
 export ShortestPathProblem, MaximumFlowProblem, MinimumCostFlowProblem
 export AssignmentProblem, AssignmentResult, isbalanced, balance
@@ -112,7 +115,8 @@ export latex
 export Chromosome, run_ga
 export JohnsonProblem, JohnsonResult, JohnsonException, makespan, johnsons_ga
 export TravelingSalesmanResult, TravelingSalesmanProblem
-export simplexiterations, SimplexProblem, createsimplexproblem, gaussjordan, OptimizationType
+export simplexiterations,
+    SimplexProblem, createsimplexproblem, gaussjordan, OptimizationType
 
 export JuMP, HiGHS
 

src/assignment.jl

@@ -92,10 +92,10 @@ function balance(problem::AssignmentProblem)::AssignmentProblem
     if n == p
         return problem
     elseif n < p
-        new_costs = vcat(problem.costs, zeros(p-n, p))
+        new_costs = vcat(problem.costs, zeros(p - n, p))
         return AssignmentProblem(new_costs)
     else
-        new_costs = hcat(problem.costs, zeros(n, n-p))
+        new_costs = hcat(problem.costs, zeros(n, n - p))
         return AssignmentProblem(new_costs)
     end
 end
@@ -146,8 +146,8 @@ function solve(a::AssignmentProblem)::AssignmentResult
     n, p = size(a.costs)
     problem = a
 
-    if n != p 
-        problem  = balance(a)
+    if n != p
+        problem = balance(a)
         n, p = size(problem.costs)
     end
 

src/game.jl

@@ -17,9 +17,9 @@ Defines the problem of a zero-sum game.
 
 - `decisionMatrix::Matrix{<:Real}`: The payoff matrix of the game designed for the row player.
 """
-struct GameProblem 
+struct GameProblem
     decisionMatrix::Matrix{<:Real}
-end 
+end
 
 
 """
@@ -36,8 +36,8 @@ A structure to hold the result of a game.
 
 """
 struct GameResult
-    probabilities
-    value
+    probabilities::Any
+    value::Any
 end
 
 

src/johnsons.jl

@@ -6,8 +6,8 @@ import ..OperationsResearchModels: solve
 
 export JohnsonResult
 export JohnsonException
-export makespan 
-export johnsons_ga 
+export makespan
+export johnsons_ga
 
 
 struct JohnsonException <: Exception
@@ -46,10 +46,10 @@ struct JohnsonResult
 end
 
 struct Process
-    start
-    duration
-    finish
-end 
+    start::Any
+    duration::Any
+    finish::Any
+end
 
 
 """
@@ -91,14 +91,21 @@ result = johnsons_ga(JohnsonProblem(times))
 println(result.permutation)
 ```
 """
-function johnsons_ga(problem::JohnsonProblem; popsize = 100, ngen = 1000, pcross = 0.8, pmutate = 0.01, nelites = 1)::JohnsonResult
+function johnsons_ga(
+    problem::JohnsonProblem;
+    popsize = 100,
+    ngen = 1000,
+    pcross = 0.8,
+    pmutate = 0.01,
+    nelites = 1,
+)::JohnsonResult
 
     times = problem.times
     n, _ = size(times)
-    
+
     function costfn(perm::Vector{Int})
         return makespan(problem, perm)
-    end 
+    end
 
     finalpop = run_ga(popsize, n, costfn, ngen, pcross, pmutate, nelites)
 
@@ -163,7 +170,7 @@ function solve(problem::JohnsonProblem)::JohnsonResult
 end
 
 function dofirst!(locrow::Int, permutation::Vector{Int})
-    for i in 1:length(permutation)
+    for i = 1:length(permutation)
         if permutation[i] == -1
             permutation[i] = locrow
             return
@@ -172,7 +179,7 @@ function dofirst!(locrow::Int, permutation::Vector{Int})
 end
 
 function dolast!(locrow::Int, permutation::Vector{Int})
-    for i in length(permutation):-1:1
+    for i = length(permutation):-1:1
         if permutation[i] == -1
             permutation[i] = locrow
             return
@@ -187,8 +194,8 @@ function johnsons_2machines(timesmatrix::Matrix)::JohnsonResult
 
     typed_inf = typemax(eltype(times))
 
-    permutation = [-1 for i in 1:n]
-    for i in 1:n
+    permutation = [-1 for i = 1:n]
+    for i = 1:n
         locrow, loccol = argmin(times).I
         if loccol == 1
             dofirst!(locrow, permutation)
@@ -207,14 +214,18 @@ function johnsons_nmachines(times::Matrix)::JohnsonResult
     maxothers = maximum(times[:, 2:(end-1)])
 
     if !((minfirst >= maxothers) || (minlast >= maxothers))
-        throw(JohnsonException("The problem cannot be reduced to a 2-machine problem: minfirst >= maxothers and/or minlast >= maxothers"))
+        throw(
+            JohnsonException(
+                "The problem cannot be reduced to a 2-machine problem: minfirst >= maxothers and/or minlast >= maxothers",
+            ),
+        )
     end
 
     Gcollection = times[:, 1:(end-1)]
     Hcollection = times[:, 2:end]
 
-    G = sum(Gcollection, dims=2)
-    H = sum(Hcollection, dims=2)
+    G = sum(Gcollection, dims = 2)
+    H = sum(Hcollection, dims = 2)
 
     return johnsons_2machines([G H])
 end
@@ -257,8 +268,8 @@ function makespan(problem::JohnsonProblem, permutation::Vector{Int})::Float64
 
     timetable = Matrix{Process}(undef, m, n)
 
-    for machine_id in 1:m
-        for task_id in 1:n
+    for machine_id = 1:m
+        for task_id = 1:n
             current_task = permutation[task_id]
             if machine_id == 1
                 if task_id == 1
@@ -270,7 +281,10 @@ function makespan(problem::JohnsonProblem, permutation::Vector{Int})::Float64
                 if task_id == 1
                     start = timetable[machine_id-1, task_id].finish
                 else
-                    start = max(timetable[machine_id, task_id-1].finish, timetable[machine_id-1, task_id].finish)
+                    start = max(
+                        timetable[machine_id, task_id-1].finish,
+                        timetable[machine_id-1, task_id].finish,
+                    )
                 end
             end
             duration = times[current_task, machine_id]
@@ -282,4 +296,4 @@ function makespan(problem::JohnsonProblem, permutation::Vector{Int})::Float64
     return timetable[end, end].finish
 end
 
-end # end of module Johnsons
+end # end of module Johnsons

src/knapsack.jl

@@ -25,7 +25,7 @@ struct KnapsackResult
     selected::Vector{Bool}
     model::JuMP.Model
     objective::Float64
-end 
+end
 
 
 
@@ -86,14 +86,14 @@ function solve(problem::KnapsackProblem)::KnapsackResult
 
     n = length(values)
     model = Model(HiGHS.Optimizer)
-    
+
     MOI.set(model, MOI.Silent(), true)
 
     @variable(model, x[1:n], Bin)
     @objective(model, Max, sum(values[i] * x[i] for i = 1:n))
     @constraint(model, sum(weights[i] * x[i] for i = 1:n) <= capacity)
     optimize!(model)
-    
+
     selected = value.(x)
     return KnapsackResult(selected, model, objective_value(model))
 end

src/minimumcostflow.jl

@@ -43,10 +43,10 @@ A structure to hold the result of the minimum cost flow problem.
 - `cost::Float64`: The total cost of the flow.
 
 """
-struct MinimumCostFlowResult 
+struct MinimumCostFlowResult
     path::Vector{Connection}
     cost::Float64
-end 
+end
 
 
 
@@ -118,7 +118,7 @@ function solve(problem::MinimumCostFlowProblem, flow::Float64)::MinimumCostFlowR
     end
 
     return MinimumCostFlowResult(solutionnodes, cost)
-end 
+end
 
 
 """
@@ -152,9 +152,9 @@ function solve(problem::MinimumCostFlowProblem)::MinimumCostFlowResult
     f = maximumflowresult.flow
 
     result::MinimumCostFlowResult = solve(problem, f)
-    
+
     return result
-end 
+end
 
 
-end # end of module MinimumCostFlow
+end # end of module MinimumCostFlow

src/network.jl

@@ -32,7 +32,7 @@ A structure to hold a directed connection between two nodes in a network.
 conn = Connection(1, 2, 5)
 ```
 """
-struct Connection 
+struct Connection
     from::Int64
     to::Int64
     value::Real
@@ -88,7 +88,12 @@ end
 
 
 
-function outflow(x::Matrix{JuMP.VariableRef}, node::Int64, nodes::Vector{Connection}, model)::Union{JuMP.AffExpr, Symbol}
+function outflow(
+    x::Matrix{JuMP.VariableRef},
+    node::Int64,
+    nodes::Vector{Connection},
+    model,
+)::Union{JuMP.AffExpr,Symbol}
     lst = []
     for conn in nodes
         if conn.from == node
@@ -99,15 +104,20 @@ function outflow(x::Matrix{JuMP.VariableRef}, node::Int64, nodes::Vector{Connect
         return :f
     end
     expr = @expression(model, 0)
-    for i = eachindex(lst)
+    for i in eachindex(lst)
         expr += x[lst[i].from, lst[i].to]
     end
     return expr
 end
 
 
 
-function inflow(x::Matrix{JuMP.VariableRef}, node::Int64, nodes::Vector{Connection}, model)::Union{JuMP.AffExpr, Symbol}
+function inflow(
+    x::Matrix{JuMP.VariableRef},
+    node::Int64,
+    nodes::Vector{Connection},
+    model,
+)::Union{JuMP.AffExpr,Symbol}
     lst = []
     for conn in nodes
         if conn.to == node
@@ -118,7 +128,7 @@ function inflow(x::Matrix{JuMP.VariableRef}, node::Int64, nodes::Vector{Connecti
         return :f
     end
     expr = @expression(model, 0)
-    for i = eachindex(lst)
+    for i in eachindex(lst)
         expr += x[lst[i].from, lst[i].to]
     end
     return expr

src/pmedian.jl

@@ -148,7 +148,7 @@ function pmedian_with_distances(distancematrix::Matrix, ncenters::Int)::PMedianR
     optimize!(model)
 
     return PMedianResult(
-        findall(x -> x == 1, value.(y)),    
+        findall(x -> x == 1, value.(y)),
         model,
         JuMP.objective_value(model),
         value.(z),