replace Array{T,1} and Array{T, 2} with Vector{T} and Matrix{T}, respectively

Author: jbytecode

CHANGELOG.md

@@ -3,6 +3,7 @@
 - Make initial solution optional in Transportation problems 
 - Add tests for the shortest problem problem
 - Add a 100x100 test problem for assignment
+- Replace `Array{Type, 1}` and `Array{Type, 2}` with `Vector{T}` and `Matrix{Type}`, respectively
 
 
 ### 0.2.5 

src/assignment.jl

@@ -14,14 +14,14 @@ import ..OperationsResearchModels: solve
 
 # Arguments
 
-- `costs::Array{T,2}`: The cost matrix of the assignment problem.
+- `costs::Matrix{T}`: The cost matrix of the assignment problem.
 
 # Description
 
 The `AssignmentProblem` struct represents an assignment problem with a cost matrix.
 """
 struct AssignmentProblem{T<:Real}
-    costs::Array{T,2}
+    costs::Matrix{T}
 end
 
 

src/cpm.jl

@@ -226,7 +226,7 @@ function findpertactivities(
     pertactivities::Vector{PertActivity},
 )
     L = length(cpmpath)
-    perts = Array{PertActivity,1}(undef, L)
+    perts = Vector{PertActivity}(undef, L)
     for i = 1:L
         currentcpmactivity = cpmpath[i]
         pertactivity = filter(x -> x.name == currentcpmactivity.name, pertactivities)[1]
@@ -284,7 +284,7 @@ function solve(problem::PertProblem)::PertResult
 
     L = length(activities)
 
-    cpmactivities = Array{CpmActivity,1}(undef, L)
+    cpmactivities = Vector{CpmActivity}(undef, L)
 
     for i = 1:L
         current::PertActivity = activities[i]

src/game.jl

@@ -24,7 +24,7 @@ end
 
 
 """
-    game(decisionMatrix::Matrix{<:Real}; verbose::Bool = false)::Array{GameResult,1}
+    game(decisionMatrix::Matrix{<:Real}; verbose::Bool = false)::Vector{GameResult}
 
     Solves a zero-sum game using the simplex method.
 
@@ -36,7 +36,7 @@ end
 # Returns
 - An array of `GameResult` objects containing the probabilities and value of the game.
 """
-function game(decisionMatrix::Matrix{<:Real}; verbose::Bool = false)::Array{GameResult,1}
+function game(decisionMatrix::Matrix{<:Real}; verbose::Bool = false)::Vector{GameResult}
     rowplayers_result = game_solver(decisionMatrix, verbose = verbose)
     columnplayers_result = game_solver(Matrix(decisionMatrix') * -1.0, verbose = verbose)
     return [rowplayers_result, columnplayers_result]

src/johnsons.jl

@@ -227,7 +227,7 @@ function makespan(times::Matrix, permutation::Vector{Int})::Float64
 
     n, m = size(times)
 
-    timetable = Array{Process,2}(undef, m, n)
+    timetable = Matrix{Process}(undef, m, n)
 
     for machine_id in 1:m
         for task_id in 1:n

src/maximumflow.jl

@@ -11,12 +11,12 @@ export MaximumFlowResult
 
 
 struct MaximumFlowResult
-    path::Array{Connection,1}
+    path::Vector{Connection}
     flow::Float64
 end
 
 struct MaximumFlowProblem
-    connections::Array{Connection,1}
+    connections::Vector{Connection}
 end
 
 
@@ -69,7 +69,7 @@ function solve(problem::MaximumFlowProblem)
 
     cns = problem.connections
 
-    function leftexpressions(node::Int64, nodes::Array{Connection,1}, model)
+    function leftexpressions(node::Int64, nodes::Vector{Connection}, model)
         lst = []
         for conn in nodes
             if conn.to == node
@@ -86,7 +86,7 @@ function solve(problem::MaximumFlowProblem)
         return expr
     end
 
-    function rightexpressions(node::Int64, nodes::Array{Connection,1}, model)
+    function rightexpressions(node::Int64, nodes::Vector{Connection}, model)
         lst = []
         for conn in nodes
             if conn.from == node

src/network.jl

@@ -18,7 +18,7 @@ struct Connection
 end
 
 
-function nodes(cns::Array{Connection,1})::Set{Int64}
+function nodes(cns::Vector{Connection})::Set{Int64}
     s = Set{Int64}()
     for conn in cns
         push!(s, conn.from)
@@ -27,7 +27,7 @@ function nodes(cns::Array{Connection,1})::Set{Int64}
     return s
 end
 
-function iseveronleft(cns::Array{Connection,1}, n::Int64)::Bool
+function iseveronleft(cns::Vector{Connection}, n::Int64)::Bool
     for conn in cns
         if conn.from == n
             return true
@@ -36,7 +36,7 @@ function iseveronleft(cns::Array{Connection,1}, n::Int64)::Bool
     return false
 end
 
-function iseveronright(cns::Array{Connection,1}, n::Int64)::Bool
+function iseveronright(cns::Vector{Connection}, n::Int64)::Bool
     for conn in cns
         if conn.to == n
             return true
@@ -45,7 +45,7 @@ function iseveronright(cns::Array{Connection,1}, n::Int64)::Bool
     return false
 end
 
-function finish(cns::Array{Connection,1})::Int64
+function finish(cns::Vector{Connection})::Int64
     nodeset = nodes(cns)
     for n in nodeset
         if !iseveronleft(cns, n)
@@ -55,7 +55,7 @@ function finish(cns::Array{Connection,1})::Int64
     error("No finish node found in connection list.")
 end
 
-function start(cns::Array{Connection,1})::Int64
+function start(cns::Vector{Connection})::Int64
     nodeset = nodes(cns)
     for n in nodeset
         if !iseveronright(cns, n)

src/shortestpath.jl

@@ -12,11 +12,11 @@ export ShortestPathResult
 
 
 struct ShortestPathProblem 
-    connections::Array{Connection,1}
+    connections::Vector{Connection}
 end 
 
 struct ShortestPathResult
-    path::Array{Connection,1}
+    path::Vector{Connection}
     cost::Float64
 end
 
@@ -68,7 +68,7 @@ function solve(problem::ShortestPathProblem)
 
     cns = problem.connections
 
-    function leftexpressions(node::Int64, nodes::Array{Connection,1}, model)
+    function leftexpressions(node::Int64, nodes::Vector{Connection}, model)
         lst = []
         for conn in nodes
             if conn.to == node
@@ -85,7 +85,7 @@ function solve(problem::ShortestPathProblem)
         return expr
     end
 
-    function rightexpressions(node::Int64, nodes::Array{Connection,1}, model)
+    function rightexpressions(node::Int64, nodes::Vector{Connection}, model)
         lst = []
         for conn in nodes
             if conn.from == node

src/simplex.jl

@@ -47,7 +47,7 @@ end
 
 function SimplexProblem()::SimplexProblem
     SimplexProblem(
-        Array{Float64,2}(undef, 0, 0),   # LHS 
+        Matrix{Float64}(undef, 0, 0),    # LHS 
         Float64[],                       # RHS 
         Float64[],                       # z 
         Maximize,                        # opttype
@@ -108,7 +108,7 @@ end
 
 function setautomaticvarnames(s::SimplexProblem)
     _, p = size(s.lhs)
-    s.varnames = Array{String,1}(undef, p)
+    s.varnames = Vector{String}(undef, p)
     for i = 1:p
         s.varnames[i] = string("x", i)
     end
@@ -425,7 +425,7 @@ function solve!(s::SimplexProblem)::SimplexProblem
 end
 
 function simplexiterations(s::SimplexProblem)::Vector{SimplexProblem}
-    iterations = Array{SimplexProblem,1}(undef, 0)
+    iterations = Vector{SimplexProblem}(undef, 0)
 
     s1 = copy(s)
     standardform!(s1)

src/transportation.jl

@@ -19,18 +19,18 @@ import ..OperationsResearchModels: solve
 
 # Arguments
 
-- `costs::Array{T,2}`: The cost matrix of the transportation problem.
-- `demand::Array{T,1}`: The demand vector of the transportation problem.
-- `supply::Array{T,1}`: The supply vector of the transportation problem.
+- `costs::Matrix{T}`: The cost matrix of the transportation problem.
+- `demand::Vector{T}`: The demand vector of the transportation problem.
+- `supply::Vector{T}`: The supply vector of the transportation problem.
 
 # Description
 
 The `TransportationProblem` struct represents a transportation problem with a cost matrix, demand vector, and supply vector.
 """
 mutable struct TransportationProblem{T<:Real}
-    costs::Array{T,2}
-    demand::Array{T,1}
-    supply::Array{T,1}
+    costs::Matrix{T}
+    demand::Vector{T}
+    supply::Vector{T}
 end