GitHub

Multiple Criteria Decision Making Tools

Copeland

JMcDM.Copeland.copeland — Function
    copeland(ordering_mat)

Arguments

  • ordering_mat::Array{Int, 2}`: Ordering matrix.

Description

The function takes an ordering matrix as input. Different ordering results are in columns. Orderings are in ascending order. The function returns the ranks. The alternative with rank 1 is the winner.

Output

  • ::Array{Int, 1}: Vector of ranks.
source

Example

julia> using JMcDM

julia> df = DataFrame(
    :c1 => [1.0, 2, 3, 4],
    :c2 => [5.0, 6, 7, 8],
    :c3 => [10.0, 11, 12, 13],
    :c4 => [20.0, 30, 40, 360],
)

julia> weights = [0.25, 0.25, 0.25, 0.25]
julia> fns = [maximum, maximum, maximum, maximum]

julia> met = [
    PIVMethod(),
    PSIMethod(),
    ROVMethod(),
    SawMethod(),
    VikorMethod(),
    WaspasMethod(),
    WPMMethod(),
]

julia> result = copeland(Matrix(df), w, fns, met)

4×8 DataFrame
 Row │ Piv    Psi    Rov    Saw    Vikor  Waspas  Wpm    Copeland 
     │ Int64  Int64  Int64  Int64  Int64  Int64   Int64  Int64    
─────┼────────────────────────────────────────────────────────────
   1 │     1      1      1      1      1       1      1         3
   2 │     2      2      2      2      2       2      2         1
   3 │     3      3      3      3      3       3      3        -1
   4 │     4      4      4      4      4       4      4        -3
source

TOPSIS

JMcDM.Topsis.topsis — Function
    topsis(decisionMat, weights, fns; normalization)

Apply TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution) method for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n candidate (or strategy) and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of function that are either minimize or maximize.
  • normalization{<:Function}: Optional normalization function.

Description

topsis() applies the TOPSIS method to rank n strategies subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::TopsisResult: TopsisResult object that holds multiple outputs including scores and best index.

Examples

julia> df = DataFrame();
julia> df[:, :x] = Float64[9, 8, 7];
julia> df[:, :y] = Float64[7, 7, 8];
julia> df[:, :z] = Float64[6, 9, 6];
julia> df[:, :q] = Float64[7, 6, 6];

julia> w = Float64[4, 2, 6, 8];

julia> df
3×4 DataFrame
 Row │ x        y        z        q       
     │ Float64  Float64  Float64  Float64 
─────┼────────────────────────────────────
   1 │     9.0      7.0      6.0      7.0
   2 │     8.0      7.0      9.0      6.0
   3 │     7.0      8.0      6.0      6.0

julia> fns = [maximum, maximum, maximum, maximum];
julia> result = topsis(Matrix(df), w, fns);

julia> result.bestIndex
2

julia> result.scores
3-element Array{Float64,1}:
 0.38768695492211824
 0.6503238218850163
 0.08347670030339041

References

Hwang, C.L.; Yoon, K. (1981). Multiple Attribute Decision Making: Methods and Applications. New York: Springer-Verlag

Celikbilek Yakup, Cok Kriterli Karar Verme Yontemleri, Aciklamali ve Karsilastirmali Saglik Bilimleri Uygulamalari ile. Editor: Muhlis Ozdemir, Nobel Kitabevi, Ankara, 2018

İşletmeciler, Mühendisler ve Yöneticiler için Operasyonel, Yönetsel ve Stratejik Problemlerin Çözümünde Çok Kriterli Karar verme Yöntemleri, Editörler: Bahadır Fatih Yıldırım ve Emrah Önder, Dora, 2. Basım, 2015, ISBN: 978-605-9929-44-8

source
    topsis(setting)

Apply TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution) method for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

topsis() applies the TOPSIS method to rank n strategies subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::TopsisResult: TopsisResult object that holds multiple outputs including scores and best index.
source

ELECTRE

JMcDM.ELECTRE.electre — Function
    electre(decisionMat, weights, fns; normalization)

Apply ELECTRE (ELimination Et Choice Translating REality) method for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n candidate (or strategy) and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of function that are either minimize or maximize.
  • normalization{<:Function}: Optional normalization function.

Description

electre() applies the ELECTRE method to rank n strategies subject to m criteria which are supposed to be either maximized or minimized. C and D values are used to determine the best strategy. If the strategy with the highest C value is same as the strategy with the lowest D value than the solution is unique. Otherwise, two strategies are reported as the solution.

Output

  • ::ElectreResult: ElectreResult object that holds multiple outputs including scores and best index.

Examples

julia> w =  [0.110, 0.035, 0.379, 0.384, 0.002, 0.002, 0.010, 0.077];
julia> Amat = [
      100 92 10 2 80 70 95 80 ;
      80  70 8  4 100 80 80 90 ;
      90 85 5 0 75 95 70 70 ; 
      70 88 20 18 60 90 95 85
    ];

julia> fns = [maximum for i in 1:8];
julia> result = electre(Amat, w, fns)


julia> result.bestIndex
(4,)

julia> result.C
4-element Array{Float64,1}:
  0.3693693693693696
  0.01501501501501501
 -2.473473473473473
  2.0890890890890894

julia> result.D
4-element Array{Float64,1}:
  0.1914244325928971
 -0.19039293350192432
  2.884307608766315
 -2.885339107857288

References

Celikbilek Yakup, Cok Kriterli Karar Verme Yontemleri, Aciklamali ve Karsilastirmali Saglik Bilimleri Uygulamalari ile. Editor: Muhlis Ozdemir, Nobel Kitabevi, Ankara, 2018

source
    electre(setting)

Apply ELECTRE (ELimination Et Choice Translating REality) method for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

electre() applies the ELECTRE method to rank n strategies subject to m criteria which are supposed to be either maximized or minimized. C and D values are used to determine the best strategy. If the strategy with the highest C value is same as the strategy with the lowest D value than the solution is unique. Otherwise, two strategies are reported as the solution.

Output

  • ::ElectreResult: ElectreResult object that holds multiple outputs including scores and best index.
source

DEMATEL

JMcDM.DEMATEL.dematel — Function
    dematel(comparisonMat; threshold = nothing)

Apply Dematel for a given comparison matrix.

Arguments:

  • comparisonMat::Matrix: n × n Matrix of input values where n is the number of criteria. Values are either 0, 1, 2, 3, or 4 which indicate the level of importance of the ith criterion relative to the jth criterion.
  • threshold::Union{Nothing, Float64}: Optional threshold used in calculating values of influence matrix. It is calculated when the argument is omitted.

Description

dematel() applies the Dematel method to calculate criteria weights, possibly for use in another multi-criteria decision making tool.

Output

  • ::DematelResult: DematelResult object that holds many results including weights for each single criterion.

Examples

julia> K = [
        0 3 0 2 0 0 0 0 3 0;
        3 0 0 0 0 0 0 0 0 2;
        4 1 0 2 1 3 1 2 3 2;
        4 1 4 0 1 2 0 1 0 0;
        3 2 3 1 0 3 0 2 0 0;
        4 1 4 4 0 0 0 1 1 3;
        3 0 0 0 0 2 0 0 0 0;
        3 0 4 3 2 3 1 0 0 0;
        4 3 2 0 0 1 0 0 0 2;
        2 1 0 0 0 0 0 0 3 0
    ];

julia> result = dematel(K);

julia> result.weights
10-element Array{Float64,1}:
 0.1686568559124561
 0.07991375718719543
 0.14006200243438863
 0.10748052790517183
 0.08789022388276985
 0.12526272598854982
 0.03067915023486491
 0.10489168834828348
 0.092654758940811
 0.06250830916550884

References

Celikbilek Yakup, Cok Kriterli Karar Verme Yontemleri, Aciklamali ve Karsilastirmali Saglik Bilimleri Uygulamalari ile. Editor: Muhlis Ozdemir, Nobel Kitabevi, Ankara, 2018

source

MOORA

JMcDM.MOORA.moora — Function
    moora_ratio(decisionMat, weights, fns; method = :reference, normalization)

Apply MOORA (Multi-Objective Optimization By Ratio Analysis) method for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n candidate (or strategy) and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of function that are either maximum or minimum.
  • method::Symbol: Either :reference or :ratio. By default, it is :reference.
  • normalization{<:Function}: Optional normalization function.

Description

moora() applies the MOORA method to rank n strategies subject to m criteria which are supposed to be either maximized or minimized. This method has two different versions. The method parameter determines the method used. It is :reference by default. For the other version, it can be set to :ratio.

Output

  • ::MooraResult: MooraResult object that holds multiple outputs including scores and best index.

References

KUNDAKCI, Nilsen. "Combined multi-criteria decision making approach based on MACBETH and MULTI-MOORA methods." Alphanumeric Journal 4.1 (2016): 17-26.

Celikbilek Yakup, Cok Kriterli Karar Verme Yontemleri, Aciklamali ve Karsilastirmali Saglik Bilimleri Uygulamalari ile. Editor: Muhlis Ozdemir, Nobel Kitabevi, Ankara, 2018

İşletmeciler, Mühendisler ve Yöneticiler için Operasyonel, Yönetsel ve Stratejik Problemlerin Çözümünde Çok Kriterli Karar verme Yöntemleri, Editörler: Bahadır Fatih Yıldırım ve Emrah Önder, Dora, 2. Basım, 2015, ISBN: 978-605-9929-44-8

source
    moora(setting; method = :reference)

Apply MOORA (Multi-Objective Optimization By Ratio Analysis) method for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.
  • method::Symbol: Either :reference or :ratio. By default, it is :reference.

Description

moora() applies the MOORA method to rank n strategies subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::MooraResult: MooraResult object that holds multiple outputs including scores and best index.
source

VIKOR

JMcDM.VIKOR.vikor — Function
    vikor(decisionMat, weights, fns; v = 0.5, normalization)

Apply VIKOR (VlseKriterijumska Optimizcija I Kaompromisno Resenje in Serbian) method for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n candidate (or strategy) and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of function that are either maximum or minimum.
  • v::Float64: Optional algorithm parameter. Default is 0.5.
  • normalization{<:Function}: Optional normalization function. Default is Normalizations.inversemaxminrangenormalization.

Description

vikor() applies the VIKOR method to rank n strategies subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::VikorResult: VikorResult object that holds multiple outputs including scores and best index.

Examples

julia> Amat = [
             100 92 10 2 80 70 95 80 ;
             80  70 8  4 100 80 80 90 ;
             90 85 5 0 75 95 70 70 ; 
             70 88 20 18 60 90 95 85
           ];


julia> fns = [maximum, maximum, maximum, maximum, maximum, maximum, maximum, maximum];

julia> result = vikor(Amat, w, fns);

julia> result.scores
4-element Array{Float64,1}:
  0.7489877763052237
  0.7332093914796731
  1.0
  0.0

julia> result.bestIndex
4

References

Celikbilek Yakup, Cok Kriterli Karar Verme Yontemleri, Aciklamali ve Karsilastirmali Saglik Bilimleri Uygulamalari ile. Editor: Muhlis Ozdemir, Nobel Kitabevi, Ankara, 2018

source
    vikor(setting; v = 0.5)

Apply VIKOR (VlseKriterijumska Optimizcija I Kaompromisno Resenje in Serbian) method for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.
  • v::Float64: Optional algorithm parameter. Default is 0.5.

Description

vikor() applies the VIKOR method to rank n strategies subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::VikorResult: VikorResult object that holds multiple outputs including scores and best index.
source

AHP

JMcDM.AHP.ahp — Function
AHP(comparisonMatrixList, criteriaComparisonMatrix)

Apply AHP (Analytical Hierarchy Process) for a given list of comparison matrices and criteria comparison matrix.

Arguments:

  • comparisonMatrixList::Vector{Matrix{Float64}}: Array of comparison matrices for all of the criteria.
  • criteriaComparisonMatrix::Matrix: Criteria comparison matrix for AHP (Comparison of columns).

Description

AHP is based on subjective comparison between criteria. The success of the method highly depends on consistency of these comparison. The method test the consistency first. At the next step, weights are calculated. The ordering of rows is determined by these weights.

Output

  • ::AHPResult: AhpResult object that holds multiple outputs including calculated weights and scores.

Examples

julia> K = [
	1 7 1/5 1/8 1/2 1/3 1/5 1
	1/7 1 1/8 1/9 1/4 1/5 1/9 1/8
	5 8 1 1/3 4 2 1 1
	8 9 3 1 7 5 3 3
	2 4 1/4 1/7 1 1/2 1/5 1/5
	3 5 1/2 1/5 2 1 1/3 1/3
	5 9 1 1/3 5 3 1 1
	1 8 1 1/3 5 3 1 1
]

A1 = [
	1 3 1/5 2
	1/3 1 1/7 1/3
	5 7 1 4
	1/2 3 1/4 1
]
A2 = [
	1 1/2 4 5
	2 1 6 7
	1/4 1/6 1 3
	1/5 1/7 1/3 1
]
A3 = [
	1 1/2 1/6 3
	2 1 1/4 5
	6 4 1 9
	1/3 1/5 1/9 1
]
A4 = [
	1 7 1/4 2
	1/7 1 1/9 1/5
	4 9 1 5
	1/2 5 1/5 1
]
A5 = [
	1 6 2 3
	1/6 1 1/4 1/3
	1/2 4 1 2
	1/3 3 1/2 1
]
A6 = [
	1 1/4 1/2 1/7
	4 1 2 1/3
	2 1/2 1 1/5
	7 3 5 1
]
A7 = [
	1 3 7 1
	1/3 1 4 1/3
	1/7 1/4 1 1/7
	1 3 7 1
]
A8 = [
	1 2 5 8
	1/2 1 3 6
	1/5 1/3 1 3
	1/8 1/6 1/3 1
]

julia> as = [A1, A2, A3, A4, A5, A6, A7, A8]
julia> result = ahp(as, K)

References

Saaty, Thomas L. "Decision making with the analytic hierarchy process." International journal of services sciences 1.1 (2008): 83-98.

source

Grey Relational Analysis

JMcDM.GREY.grey — Function
    grey(decisionMat, weights, fs; zeta, normalization)

Perform GRA (Grey Relational Analysis) for a given decision matrix and weights.

Arguments:

  • decisionMat::Matrix: n × m matrix of decision matrix in type of DataFrame.
  • weights::Array{Float64, 1}: m-vector of weights for criteria.
  • fs::Array{Function, 1}: m-vector of functions that are either maximize or minimize for each single criterion.
  • zeta::Float64: zeta parameter for the algorithm. The default is 0.5.
  • normalization{<:Function}: Optional normalization function.

Description

Applies GRA (Grey Relational Analysis).

Output

  • ::GreyResult: GreyResult object that holds many values including ordering of strategies or candidates and best index.

Examples

julia> # Decision matrix of 5 candidates and 6 criteria.
julia> df = DataFrame(
               :K1 => [105000.0, 120000, 150000, 115000, 135000],
               :K2 => [105.0, 110, 120, 105, 115],
               :K3 => [10.0, 15, 12, 20, 15],
               :K4 => [4.0, 4, 3, 4, 5],
               :K5 => [300.0, 500, 550, 600, 400],
               :K6 => [10.0, 8, 12, 9, 9]
        )
5×6 DataFrame
 Row │ K1        K2       K3       K4       K5       K6      
     │ Float64   Float64  Float64  Float64  Float64  Float64 
─────┼───────────────────────────────────────────────────────
   1 │ 105000.0    105.0     10.0      4.0    300.0     10.0
   2 │ 120000.0    110.0     15.0      4.0    500.0      8.0
   3 │ 150000.0    120.0     12.0      3.0    550.0     12.0
   4 │ 115000.0    105.0     20.0      4.0    600.0      9.0
   5 │ 135000.0    115.0     15.0      5.0    400.0      9.0

julia> # Direction of optimization for each single criterion
julia> functionlist = [minimum, maximum, minimum, maximum, maximum, minimum];

julia> # Weights
julia> w = [0.05, 0.20, 0.10, 0.15, 0.10, 0.40];

julia> result = grey(Matrix(df), w, functionlist);

julia> result.scores
5-element Array{Float64,1}:
 0.525
 0.7007142857142857
 0.5464285714285715
 0.5762820512820512
 0.650952380952381

julia> result.bestIndex
2

References

İşletmeciler, Mühendisler ve Yöneticiler için Operasyonel, Yönetsel ve Stratejik Problemlerin Çözümünde Çok Kriterli Karar verme Yöntemleri, Editörler: Bahadır Fatih Yıldırım ve Emrah Önder, Dora, 2. Basım, 2015, ISBN: 978-605-9929-44-8

source
    grey(setting; zeta)

Perform GRA (Grey Relational Analysis) for a given decision matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.
  • zeta::Float64: zeta parameter for the algorithm. The default is 0.5.

Description

Applies GRA (Grey Relational Analysis).

Output

  • ::GreyResult: GreyResult object that holds many values including ordering of strategies or candidates and best index.
source

Non-dominated Sorting

JMcDM.NDS.nds — Function
nds(data, fns)

Sort multidimensional data using non-dominated sorting algorithm.

Arguments

  • data::Matrix: n x k desicion matrix with n cases and k criteria.
  • fns::Array{<:Function, 1}: Vector of functions with elements of maximum or minimum.

Output

  • ::NDSResult: NDSResult object that holds multiple outputs including ranks and best index.

Examples

 julia> cases = [
               1.0 2.0 3.0;
               2.0 1.0 3.0;
               1.0 3.0 2.0;
               4.0 5.0 6.0
           ];


julia> result = nds(cases, [maximum, maximum, maximum]);

julia> result.ranks
4-element Array{Int64,1}:
 0
 0
 0
 3

julia> result.bestIndex
4

References

Deb, Kalyanmoy, et al. "A fast elitist non-dominated sorting genetic algorithm for multi-objective optimization: NSGA-II." International conference on parallel problem solving from nature. Springer, Berlin, Heidelberg, 2000.

source

SAW

JMcDM.SAW.saw — Function
    saw(decisionMat, weights, fns; normalization)

Apply SAW (Simple Additive Weighting) method for a given matrix and weights. This method also known as WSM (Weighted Sum Model)

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n candidate (or strategy) and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns.
  • normalization{<:Function}: Optional normalization function.

Description

saw() applies the SAW method to rank n strategies subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::SawResult: SawResult object that holds multiple outputs including scores, rankings, and best index.

Examples

julia> decmat = [4.0  7  3  2  2  2  2;
                 4.0  4  6  4  4  3  7;
                 7.0  6  4  2  5  5  3;
                 3.0  2  5  3  3  2  5;
                 4.0  2  2  5  5  3  6];

julia> fns = [maximum for i in 1:7];

julia> weights = [0.283, 0.162, 0.162, 0.07, 0.085, 0.162, 0.076];

julia> result = saw(decmat, weights, fns);

julia> result.scores
5-element Array{Float64,1}:
 0.5532285714285714
 0.7134857142857142
 0.8374285714285714
 0.5146571428571429
 0.5793428571428572

julia> result.bestIndex
3

References

Afshari, Alireza, Majid Mojahed, and Rosnah Mohd Yusuff. "Simple additive weighting approach to personnel selection problem." International Journal of Innovation, Management and Technology 1.5 (2010): 511.

source
    saw(setting)

Apply SAW (Simple Additive Weighting) method for a given matrix and weights. This method also known as WSM (Weighted Sum Model)

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

saw() applies the SAW method to rank n strategies subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::SawResult: SawResult object that holds multiple outputs including scores, rankings, and best index.
source

ARAS

JMcDM.ARAS.aras — Function
aras(decisionMat, weights, fs; normalization)

Apply ARAS (Additive Ratio ASsessment) method for a given matrix, weights and, type of criteria.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alternatives and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fs::Array{<:Function,1}: m-vector of type of criteria. The benefit criteria shown with "maximum", and the cost criteria shown with "minimum".
  • normalization{<:Function}: Optional normalization function.

Description

aras() applies the ARAS method to rank n alternatives subject to m criteria and criteria type vector.

Output

  • ::ARASResult: ARASResult object that holds multiple outputs including scores and best index.

Examples

julia> df = DataFrame(
    :K1 => [105000.0, 120000, 150000, 115000, 135000],
    :K2 => [105.0, 110, 120, 105, 115],
    :K3 => [10.0, 15, 12, 20, 15],
    :K4 => [4.0, 4, 3, 4, 5],
    :K5 => [300.0, 500, 550, 600, 400],
    :K6 => [10.0, 8, 12, 9, 9]
)
julia> df
5×6 DataFrame
 Row │ K1        K2       K3       K4       K5       K6      
     │ Float64   Float64  Float64  Float64  Float64  Float64 
─────┼───────────────────────────────────────────────────────
   1 │ 105000.0    105.0     10.0      4.0    300.0     10.0
   2 │ 120000.0    110.0     15.0      4.0    500.0      8.0
   3 │ 150000.0    120.0     12.0      3.0    550.0     12.0
   4 │ 115000.0    105.0     20.0      4.0    600.0      9.0
   5 │ 135000.0    115.0     15.0      5.0    400.0      9.0

julia> result = aras(Matrix(df), w, fs);
julia> result.bestIndex
2
julia> result.scores
5-element Array{Float64,1}:
 0.8142406768388222
 0.8928861957614441
 0.764157900073527
 0.8422546181927358
 0.8654063509472654

References

Zavadskas, E. K., & Turskis, Z. (2010). A new additive ratio assessment (ARAS) method in multicriteria decision‐making. Technological and Economic Development of Economy, 16(2), 159-172. Yıldırım, B. F. (2015). "Çok Kriterli Karar Verme Problemlerinde ARAS Yöntemi". Kafkas Üniversitesi İktisadi ve İdari Bilimler Fakültesi Dergisi, 6 (9), 285-296. http://dx.doi.org/10.18025/kauiibf.65151

source
aras(setting)

Apply ARAS (Additive Ratio ASsessment) method for a given matrix, weights and, type of criteria.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

aras() applies the ARAS method to rank n alternatives subject to m criteria and criteria type vector.

Output

  • ::ARASResult: ARASResult object that holds multiple outputs including scores and best index.
source

WPM

JMcDM.WPM.wpm — Function
    wpm(decisionMat, weights, fns)

Apply WPM (Weighted Product Method) for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alterntives and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns.
  • normalization{<:Function}: Optional normalization function.

Description

wpm() applies the WPM method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::WPMResult: WPMResult object that holds multiple outputs including scores, rankings, and best index.

Examples

julia> decmat = [3        12.5        2        120        14        3;
       5        15        3        110        38        4;
       3        13        2        120        19        3;
       4        14        2        100        31        4;
       3        15        1.5        125        40        4]
5×6 Array{Float64,2}:
 3.0  12.5  2.0  120.0  14.0  3.0
 5.0  15.0  3.0  110.0  38.0  4.0
 3.0  13.0  2.0  120.0  19.0  3.0
 4.0  14.0  2.0  100.0  31.0  4.0
 3.0  15.0  1.5  125.0  40.0  4.0


julia> weights = [0.221, 0.159, 0.175, 0.127, 0.117, 0.201];

julia> fns = [maximum, minimum, minimum, maximum, minimum, maximum];

julia> result = wpm(decmat, weights, fns);

julia> result.scores
5-element Array{Float64,1}:
 0.7975224331331252
 0.7532541470584717
 0.7647463553356331
 0.7873956894790834
 0.7674278741781709

julia> result.bestIndex
1

References

Zavadskas, E. K., Turskis, Z., Antucheviciene, J., & Zakarevicius, A. (2012). Optimization of Weighted Aggregated Sum Product Assessment. Elektronika Ir Elektrotechnika, 122(6), 3-6. https://doi.org/10.5755/j01.eee.122.6.1810

source
    wpm(setting)

Apply WPM (Weighted Product Method) for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

wpm() applies the WPM method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::WPMResult: WPMResult object that holds multiple outputs including scores, rankings, and best index.
source

WASPAS

JMcDM.WASPAS.waspas — Function
    waspas(decisionMat, weights, fns; lambda = 0.5, normalization)

Apply WASPAS (Weighted Aggregated Sum Product ASsessment ) for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alterntives and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns.
  • lambda::Float64: joint criterion. 0<=lambda<=1, default=0.5.
  • normalization{<:Function}: Normalization function. Default is Normalizations.dividebycolumnmaxminnormalization.

Description

waspas() applies the WASPAS method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::WASPASResult: WASPASResult object that holds multiple outputs including scores, rankings, and best index.

Examples

julia> decmat = [3        12.5        2        120        14        3;
       5        15        3        110        38        4;
       3        13        2        120        19        3;
       4        14        2        100        31        4;
       3        15        1.5        125        40        4]
5×6 Array{Float64,2}:
 3.0  12.5  2.0  120.0  14.0  3.0
 5.0  15.0  3.0  110.0  38.0  4.0
 3.0  13.0  2.0  120.0  19.0  3.0
 4.0  14.0  2.0  100.0  31.0  4.0
 3.0  15.0  1.5  125.0  40.0  4.0


julia> weights = [0.221, 0.159, 0.175, 0.127, 0.117, 0.201];

julia> fns = [maximum, minimum, minimum, maximum, minimum, maximum];

julia> lambda = 0.5;

julia> result = wpm(decmat, weights, fns, lambda);

julia> result.scores
5-element Array{Float64,1}:
 0.8050212165665626
 0.7750597051081832
 0.770180748518019
 0.7964243424353943
 0.7882389370890854

 julia> result.bestIndex
 1

References

Zavadskas, E. K., Turskis, Z., Antucheviciene, J., & Zakarevicius, A. (2012). Optimization of Weighted Aggregated Sum Product Assessment. Elektronika Ir Elektrotechnika, 122(6), 3-6. https://doi.org/10.5755/j01.eee.122.6.1810 Aytaç Adalı, E. & Tuş Işık, A.. (2017). Bir Tedarikçi Seçim Problemi İçin SWARA ve WASPAS Yöntemlerine Dayanan Karar Verme Yaklaşımı. International Review of Economics and Management, 5 (4) , 56-77. DOI: 10.18825/iremjournal.335408

source
    waspas(setting; lambda = 0.5)

Apply WASPAS (Weighted Aggregated Sum Product ASsessment ) for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.
  • lambda::Float64: joint criterion. 0<=lambda<=1, default=0.5.

Description

waspas() applies the WASPAS method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::WASPASResult: WASPASResult object that holds multiple outputs including scores, rankings, and best index.
source

EDAS

JMcDM.EDAS.edas — Function
    edas(decisionMat, weights, fns)

Apply EDAS (Evaluation based on Distance from Average Solution) for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alterntives and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns.

Description

edas() applies the EDAS method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::EDASResult: EDASResult object that holds multiple outputs including scores, rankings, and best index.

Examples

julia> decmat = [5000 5 5300 450;
       4500 5 5000 400;
       4500 4 4700 400;
       4000 4 4200 400;
       5000 4 7100 500;
       5000 5 5400 450;
       5500 5 6200 500;
       5000 4 5800 450]
8×4 Array{Int64,2}:
 5000  5  5300  450
 4500  5  5000  400
 4500  4  4700  400
 4000  4  4200  400
 5000  4  7100  500
 5000  5  5400  450
 5500  5  6200  500
 5000  4  5800  450


julia> weights = [0.25, 0.25, 0.25, 0.25];

julia> fns = [maximum, maximum, minimum, minimum];

julia> result = edas(decmat, weights, fns);

julia> result.scores
8-element Array{Float64,1}:
 0.7595941163602383
 0.8860162461306114
 0.6974721951442592
 0.739657763190231
 0.05908329207449442
 0.7318326305342363
 0.6416913873322523
 0.38519414045559647

julia> result.bestIndex
2

References

Keshavarz Ghorabaee, M., Zavadskas, E. K., Olfat, L., & Turskis, Z. (2015). Multi-criteria inventory classification using a new method of evaluation based on distance from average solution (EDAS). Informatica, 26(3), 435-451.

Ulutaş, A. (2017). EDAS Yöntemi Kullanılarak Bir Tekstil Atölyesi İçin Dikiş Makinesi Seçimi. İşletme Araştırmaları Dergisi, 9(2), 169-183.

source
    edas(setting)

Apply EDAS (Evaluation based on Distance from Average Solution) for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

edas() applies the EDAS method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::EDASResult: EDASResult object that holds multiple outputs including scores, rankings, and best index.
source

MARCOS

JMcDM.MARCOS.marcos — Function
    marcos(decisionMat, weights, fns)

Apply MARCOS (Measurement Alternatives and Ranking according to COmpromise Solution) for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alterntives and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns.

Description

marcos() applies the MARCOS method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::MARCOSResult: MARCOSResult object that holds multiple outputs including scores, rankings, and best index.

Examples

julia> decmat = [8.675 8.433 8.000 7.800 8.025 8.043;
       8.825 8.600 7.420 7.463 7.825 8.229;
       8.325 7.600 8.040 7.700 7.925 7.600;
       8.525 8.667 7.180 7.375 7.750 8.071]
4×6 Array{Float64,2}:
 8.675  8.433  8.0   7.8    8.025  8.043
 8.825  8.6    7.42  7.463  7.825  8.229
 8.325  7.6    8.04  7.7    7.925  7.6
 8.525  8.667  7.18  7.375  7.75   8.071


julia> weights = [0.1901901901901902 , 0.15915915915915918 , 0.19819819819819823, 0.1901901901901902, 0.15115115115115116, 0.11111111111111112];

julia> fns = [maximum, maximum, maximum, maximum, maximum, maximum];

julia> result = marcos(decmat, weights, fns);

julia> result.scores
4-element Array{Float64,1}:
 0.6848657890705123
 0.6727670074308345
 0.6625969531206817
 0.6611030275027843

julia> result.bestIndex
1

References

Stević, Z., Pamučar, D., Puška, A., Chatterjee, P., Sustainable supplier selection in healthcare industries using a new MCDM method: Measurement Alternatives and Ranking according to COmpromise Solution (MARCOS), Computers & Industrial Engineering (2019), doi: https://doi.org/10.1016/j.cie.2019.106231

Puška, A., Stojanović, I., Maksimović, A., & Osmanović, N. (2020). Evaluation software of project management used measurement of alternatives and ranking according to compromise solution (MARCOS) method. Operational Research in Engineering Sciences: Theory and Applications, 3(1), 89-102.

source
    marcos(setting)

Apply MARCOS (Measurement Alternatives and Ranking according to COmpromise Solution) for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting

Description

marcos() applies the MARCOS method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::MARCOSResult: MARCOSResult object that holds multiple outputs including scores, rankings, and best index.
source

MABAC

JMcDM.MABAC.mabac — Function
    mabac(decisionMat, weights, fns; normalization)

Apply MABAC (Multi-Attributive Border Approximation area Comparison) for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alternatives and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns.
  • normalization{<:Function}: Optional normalization function.

Description

mabac() applies the MABAC method to rank n alternatives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::MABACResult: MABACResult object that holds multiple outputs including scores, rankings, and best index.

Examples

julia> decmat = [2 1 4 7 6 6 7 3000;
       4 1 5 6 7 7 6 3500;
       3 2 6 6 5 6 8 4000;
       5 1 5 7 6 7 7 3000;
       4 2 5 6 7 7 6 3000;
       3 2 6 6 6 6 6 3500]
6×8 
Array{Int64,2}:
 2  1  4  7  6  6  7  3000
 4  1  5  6  7  7  6  3500
 3  2  6  6  5  6  8  4000
 5  1  5  7  6  7  7  3000
 4  2  5  6  7  7  6  3000
 3  2  6  6  6  6  6  3500


julia> weights = [0.293, 0.427, 0.067, 0.027, 0.053, 0.027, 0.053, 0.053];

julia> fns = [maximum, maximum, maximum, maximum, maximum, maximum, maximum, minimum];

julia> result = mabac(decmat, weights, fns);

julia> result.scores
6-element Array{Float64,1}:
 -0.3113160790692055
 -0.10898274573587217
  0.2003505875974611
  0.0421839209307945
  0.3445172542641278
  0.2003505875974611

julia> result.bestIndex
5

References

Pamučar, D., & Ćirović, G. (2015). The selection of transport and handling resources in logistics centers using Multi-Attributive Border Approximation area Comparison (MABAC). Expert Systems with Applications, 42(6), 3016–3028. doi:10.1016/j.eswa.2014.11.057

Ulutaş, A. (2019). Entropi ve MABAC yöntemleri ile personel seçimi. OPUS–International Journal of Society Researches, 13(19), 1552-1573. DOI: 10.26466/opus.580456

source
    mabac(setting)

Apply MABAC (Multi-Attributive Border Approximation area Comparison) for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

mabac() applies the MABAC method to rank n alternatives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::MABACResult: MABACResult object that holds multiple outputs including scores, rankings, and best index.
source

MAIRCA

JMcDM.MAIRCA.mairca — Function
    mairca(decisionMat, weights, fns; normalization)

Apply MAIRCA (Multi Attributive Ideal-Real Comparative Analysis) for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alternatives and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns.
  • normalization{<:Function}: Optional normalization function.

Description

mairca() applies the MAIRCA method to rank n alternatives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::MAIRCAResult: MAIRCAResult object that holds multiple outputs including scores, rankings, and best index.

Examples

julia> decmat = [6.952 8.000 6.649 7.268 8.000 7.652 6.316;
       7.319 7.319 6.604 7.319 8.000 7.652 5.313;
       7.000 7.319 7.652 6.952 7.652 6.952 4.642;
       7.319 6.952 6.649 7.319 7.652 6.649 5.000]
4×7 Array{Float64,2}:
 6.952  8.0    6.649  7.268  8.0    7.652  6.316
 7.319  7.319  6.604  7.319  8.0    7.652  5.313
 7.0    7.319  7.652  6.952  7.652  6.952  4.642
 7.319  6.952  6.649  7.319  7.652  6.649  5.0


julia> weights = [0.172, 0.165, 0.159, 0.129, 0.112, 0.122, 0.140];

julia> fns = [maximum, maximum, maximum, maximum, maximum, maximum, minimum];

julia> result = mairca(decmat, weights, fns);

julia> result.scores
4-element Array{Float64,1}:
 0.12064543054088471
 0.08066456363291889
 0.14586265389012484
 0.14542366685864686

julia> result.bestIndex
2

References

Pamučar, D., Lukovac, V., Božanić, D., & Komazec, N. (2018). Multi-criteria FUCOM-MAIRCA model for the evaluation of level crossings: case study in the Republic of Serbia. Operational Research in Engineering Sciences: Theory and Applications, 1(1), 108-129.

Ulutaş A.(2019),Swara Ve Mairca Yöntemleri İle Catering Firması Seçimi,BMIJ, (2019), 7(4): 1467-1479 http://dx.doi.org/10.15295/bmij.v7i4.1166

source
    mairca(setting)

Apply MAIRCA (Multi Attributive Ideal-Real Comparative Analysis) for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

mairca() applies the MAIRCA method to rank n alternatives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::MAIRCAResult: MAIRCAResult object that holds multiple outputs including scores, rankings, and best index.
source

COPRAS

JMcDM.COPRAS.copras — Function
copras(decisionMat, weights, fs; normalization)

Apply COPRAS (COmplex PRoportional ASsesment) method for a given matrix, weights and, type of criteria.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alternatives and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fs::Array{<:Function,1}: m-vector of type of criteria. The benefit criteria shown with "maximum", and the cost criteria shown with "minimum".
  • normalization{<:Function}: Optional normalization function.

Description

copras() applies the COPRAS method to rank n alternatives subject to m criteria and criteria type vector.

Output

  • ::COPRASResult: COPRASResult object that holds multiple outputs including scores and best index.

Examples

julia> decmat = [2.50 240 57 45 1.10 0.333333;
       2.50 285 60 75 4.00 0.428571;
       4.50 320 100 65 7.50 1.111111;
       4.50 365 100 90 7.50 1.111111;
       5.00 400 100 90 11.00 1.111111;
       2.50 225 60 45 1.10 0.333333;
       2.50 270 57 60 4.00 0.428571;
       4.50 330 100 70 7.50 1.111111;
       4.50 365 100 80 7.50 1.111111;
       5.00 380 110 65 8.00 1.111111;
       2.50 285 65 80 4.00 0.400000;
       4.00 280 75 65 4.00 0.400000;
       4.50 365 102 95 7.50 1.111111;
       4.50 400 102 95 7.50 1.111111;
       6.00 450 110 95 11.00 1.176471;
       6.00 510 110 105 11.00 1.176471;
       6.00 330 140 110 18.50 1.395349;
       2.50 240 65 80 4.00 0.400000;
       4.00 280 75 75 4.00 0.400000;
       4.50 355 102 95 7.50 1.111111;
       4.50 385 102 90 7.50 1.111111;
       5.00 385 114 95 7.50 1.000000;
       6.00 400 110 90 11.00 1.000000;
       6.00 480 110 95 15.00 1.000000;
       6.00 440 140 100 18.50 1.200000;
       6.00 500 140 100 18.50 1.200000;
       5.00 450 125 100 15.00 1.714286;
       6.00 500 150 125 18.50 1.714286;
       6.00 515 180 140 22.00 2.307692;
       7.00 550 200 150 30.00 2.307692;
       6.00 500 180 140 15.00 2.307692;
       6.00 500 180 140 18.50 2.307692;
       6.00 500 180 140 22.00 2.307692;
       7.00 500 180 140 30.00 2.307692;
       7.00 500 200 140 37.00 2.307692;
       7.00 500 200 140 45.00 2.307692;
       7.00 500 200 140 55.00 2.307692;
       7.00 500 200 140 75.00 2.307692]
38×6 Array{Float64,2}:
 2.5  240.0   57.0   45.0   1.1  0.333333
 2.5  285.0   60.0   75.0   4.0  0.428571
 4.5  320.0  100.0   65.0   7.5  1.11111
 4.5  365.0  100.0   90.0   7.5  1.11111
 5.0  400.0  100.0   90.0  11.0  1.11111
 2.5  225.0   60.0   45.0   1.1  0.333333
 2.5  270.0   57.0   60.0   4.0  0.428571
 4.5  330.0  100.0   70.0   7.5  1.11111
 4.5  365.0  100.0   80.0   7.5  1.11111
 5.0  380.0  110.0   65.0   8.0  1.11111
 2.5  285.0   65.0   80.0   4.0  0.4
 ⋮                               ⋮
 6.0  500.0  150.0  125.0  18.5  1.71429
 6.0  515.0  180.0  140.0  22.0  2.30769
 7.0  550.0  200.0  150.0  30.0  2.30769
 6.0  500.0  180.0  140.0  15.0  2.30769
 6.0  500.0  180.0  140.0  18.5  2.30769
 6.0  500.0  180.0  140.0  22.0  2.30769
 7.0  500.0  180.0  140.0  30.0  2.30769
 7.0  500.0  200.0  140.0  37.0  2.30769
 7.0  500.0  200.0  140.0  45.0  2.30769
 7.0  500.0  200.0  140.0  55.0  2.30769
 7.0  500.0  200.0  140.0  75.0  2.30769

julia> weights = [0.1667, 0.1667, 0.1667, 0.1667, 0.1667, 0.1667];

julia> fns = [maximum, maximum, maximum, maximum, maximum, minimum];

julia> result = copras(decmat, w, fs);

julia> result.bestIndex
38

julia> result.scores
38-element Array{Float64,1}:
 0.021727395411605937
 0.019814414550092637
 0.01789214190869233
 0.01624057709923278
 0.01507318798582843
 0.021837811311495522
 0.020735423365838293
 0.01754833367014725
 0.016658288043259514
 0.016258710042371068
 0.019388734250223458
 ⋮
 0.01064826476628102
 0.01000964101170639
 0.007056714858865703
 0.010627520153194962
 0.010419795157349462
 0.010212070161503961
 0.00876261130160425
 0.007733739643860005
 0.007258939653356005
 0.006665439665226005
 0.005478439688966004

References

Kaklauskas, A., Zavadskas, E. K., Raslanas, S., Ginevicius, R., Komka, A., & Malinauskas, P. (2006). Selection of low-e windows in retrofit of public buildings by applying multiple criteria method COPRAS: A Lithuanian case. Energy and buildings, 38(5), 454-462. Özdağoğlu, A. (2013). İmalat işletmeleri için eksantrik pres alternatiflerinin COPRAS yöntemi ile karşılaştırılması. Gümüşhane Üniversitesi Sosyal Bilimler Enstitüsü Elektronik Dergisi, 4(8), 1-22. Yıldırım, B. F., Timor, M. (2019). "Bulanık ve Gri COPRAS Yöntemleri Kullanılarak Tedarikçi Seçim Modeli Geliştirilmesi". Optimum Ekonomi ve Yönetim Bilimleri Dergisi, 6 (2), 283-310.

source
copras(setting)

Apply COPRAS (COmplex PRoportional ASsesment) method for a given matrix, weights and, type of criteria.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

copras() applies the COPRAS method to rank n alternatives subject to m criteria and criteria type vector.

Output

  • ::COPRASResult: COPRASResult object that holds multiple outputs including scores and best index.
source

PROMETHEE

JMcDM.PROMETHEE.promethee — Function
    promethee(decisionMatrix, weights, fns, prefs, qs, ps)

Apply PROMETHEE (Preference Ranking Organization METHod for Enrichment of Evaluations) method for a given matrix and weights.

Arguments:

  • decisionMatrix::Matrix: n × m matrix of objective values for n candidate (or strategy) and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of functions that are either maximum or minimum.
  • prefs::Array{Function, 1}: m-vector of preference functions that are prometLinear, prometVShape, prometUShape, prometQuasi, or prometLevel.
  • qs::Array{Float64, 1}: m-vector of q parameters that is used in corresponding preference function.
  • ps::Array{Float64, 1}: m-vector of p parameters that is used in corresponding preference function

Description

promethee() applies the PROMETHEE method to rank n strategies subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::PrometheeResult: PrometheeResult object that holds multiple outputs including scores and best index.

Examples

julia> decmat = [42.0 35 43 51; 
                     89 72 92 85;
                     14 85 17 40;
                     57 60 45 80;
                     48 32 43 40;
                     71 45 60 85;
                     69 40 72 55;
                     64 35 70 60];



julia> qs = [49, nothing, 45, 30];

julia> ps = [100, 98, 95, 80];

julia> weights = [0.25, 0.35, 0.22, 0.18];

julia> fns = [maximum, maximum, maximum, maximum];

julia> prefs = [prometLinear, prometVShape, prometLinear, prometLinear];

julia> result = promethee(decmat, weights, fns, prefs, qs, ps);

julia> result.scores
8-element Array{Float64,1}:
  0.0698938775510204
 -0.148590956382553
 -0.061361984793917565
 -0.04780408163265306
  0.09859591836734694
 -0.0006389755902360891
  0.03236974789915966
  0.057536454581832736

julia> result.bestIndex
5

References

İşletmeciler, Mühendisler ve Yöneticiler için Operasyonel, Yönetsel ve Stratejik Problemlerin Çözümünde Çok Kriterli Karar verme Yöntemleri, Editörler: Bahadır Fatih Yıldırım ve Emrah Önder, Dora, 2. Basım, 2015, ISBN: 978-605-9929-44-8

source
    promethee(setting, prefs, qs, ps)

Apply PROMETHEE (Preference Ranking Organization METHod for Enrichment of Evaluations) method for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.
  • prefs::Array{Function, 1}: m-vector of preference functions that are prometLinear, prometVShape, prometUShape, prometQuasi, or prometLevel.
  • qs::Array{Float64, 1}: m-vector of q parameters that is used in corresponding preference function.
  • ps::Array{Float64, 1}: m-vector of p parameters that is used in corresponding preference function

Description

promethee() applies the PROMETHEE method to rank n strategies subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::PrometheeResult: PrometheeResult object that holds multiple outputs including scores and best index.
source

CoCoSo

JMcDM.COCOSO.cocoso — Function
    cocoso(decisionMat, weights, fns; lambda, normalization)

Apply CoCoSo (Combined Compromise Solution) method for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alternatives and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns.
  • lambda::Float64: joint criterion. 0<=lambda<=1, default=0.5.
  • normalization{<:Function}: Optional normalization function.

Description

cocoso() applies the CoCoSo method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::CoCoSoResult: CoCoSoResult object that holds multiple outputs including scores, rankings, and best index.

Examples

julia> decmat = [3        12.5        2        120        14        3;
       5        15        3        110        38        4;
       3        13        2        120        19        3;
       4        14        2        100        31        4;
       3        15        1.5        125        40        4]
5×6 Array{Float64,2}:
 3.0  12.5  2.0  120.0  14.0  3.0
 5.0  15.0  3.0  110.0  38.0  4.0
 3.0  13.0  2.0  120.0  19.0  3.0
 4.0  14.0  2.0  100.0  31.0  4.0
 3.0  15.0  1.5  125.0  40.0  4.0

julia> weights = [0.221, 0.159, 0.175, 0.127, 0.117, 0.201];

julia> fns = [maximum, minimum, minimum, maximum, minimum, maximum];

julia> result = cocoso(decmat, weights, fns, lambda = 0.5);

julia> result.scores
5-element Vector{Float64}:
 1.922475728710679
 1.8144169615649441
 1.8374089377955838
 2.1842047284481
 1.6232623861380282

julia> result.bestIndex
4

References

Yazdani, M., Zarate, P., Kazimieras Zavadskas, E. and Turskis, Z. (2019), "A combined compromise solution (CoCoSo) method for multi-criteria decision-making problems", Management Decision, Vol. 57 No. 9, pp. 2501-2519. https://doi.org/10.1108/MD-05-2017-0458

source
    cocoso(setting; lambda)

Apply CoCoSo (Combined Compromise Solution) method for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object
  • lambda::Float64: joint criterion. 0<=lambda<=1, default=0.5.

Description

cocoso() applies the CoCoSo method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::CoCoSoResult: CoCoSoResult object that holds multiple outputs including scores, rankings, and best index.
source

Critic

JMcDM.CRITIC.critic — Function
    critic(decisionMat, fns; normalization)

Apply CRITIC (Combined Compromise Solution) method for a given matrix and criteria types.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alternatives and m criteria
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns.
  • normalization{<:Function}: Optional normalization function.

Description

critic() applies the CRITIC method to calculate weights using a decision matrix with n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::CRITICResult: CRITICResult object that holds multiple outputs including weighting and best index.

Examples


julia> decmat
3×4 Array{Float64,2}:
 12.9918  0.7264  -1.1009  1.59814
  4.1201  5.8824   3.4483  1.02156
  4.1039  0.0     -0.5076  0.984469


julia> fns = [maximum, maximum, minimum, maximum];

julia> result = critic(decmat, fns);

julia> result.w
4-element Array{Float64,1}:
 0.16883905506169491
 0.41844653698732126
 0.24912338769165807
 0.16359102025932576

References

Diakoulaki, D., Mavrotas, G., & Papayannakis, L. (1995). Determining objective weights in multiple criteria problems: The critic method. Computers & Operations Research, 22(7), 763–770. doi:10.1016/0305-0548(94)00059-h Akçakanat, Ö., Aksoy, E., Teker, T. (2018). CRITIC ve MDL Temelli EDAS Yöntemi ile TR-61 Bölgesi Bankalarının Performans Değerlendirmesi. Süleyman Demirel Üniversitesi Sosyal Bilimler Enstitüsü Dergisi, 1 (32), 1-24.

source
    critic(setting)

Apply CRITIC (Combined Compromise Solution) method for a given matrix and criteria types.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

critic() applies the CRITIC method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::CRITICResult: CRITICResult object that holds multiple outputs including weighting and best index.
source

CODAS

JMcDM.CODAS.codas — Function
codas(decisionMat, weights, fs; normalization)

Apply CODAS (COmbinative Distance-based ASsessment) method for a given matrix, weights and, type of criteria.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alternatives and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fs::Array{<:Function,1}: m-vector of type of criteria. The benefit criteria shown with "maximum", and the cost criteria shown with "minimum".
  • tau::Float64: tau parameter for the algorithm. The default is 0.02.
  • normalization{<:Function}: Optional normalization function.

Description

codas() applies the CODAS method to rank n alternatives subject to m criteria and criteria type vector.

Output

  • ::CODASResult: CODASResult object that holds multiple outputs including scores and best index.

Examples

julia> decmat
7×5 Array{Float64,2}:
 60.0   0.4   2540.0   500.0   990.0
  6.35  0.15  1016.0  3000.0  1041.0
  6.8   0.1   1727.2  1500.0  1676.0
 10.0   0.2   1000.0  2000.0   965.0
  2.5   0.1    560.0   500.0   915.0
  4.5   0.08  1016.0   350.0   508.0
  3.0   0.1   1778.0  1000.0   920.0

julia> df = DataFrame(decmat)
7×5 DataFrame
 Row │ x1       x2       x3       x4       x5      
     │ Float64  Float64  Float64  Float64  Float64 
─────┼─────────────────────────────────────────────
   1 │   60.0      0.4    2540.0    500.0    990.0
   2 │    6.35     0.15   1016.0   3000.0   1041.0
   3 │    6.8      0.1    1727.2   1500.0   1676.0
   4 │   10.0      0.2    1000.0   2000.0    965.0
   5 │    2.5      0.1     560.0    500.0    915.0
   6 │    4.5      0.08   1016.0    350.0    508.0
   7 │    3.0      0.1    1778.0   1000.0    920.0

julia> result = codas(Matrix(df), w, fs);
julia> result.bestIndex
2
julia> result.scores
7-element Array{Float64,1}:
  0.5121764914884954
  1.463300034504913
  1.0715325899642418
 -0.21246799780012637
 -1.8515205523193041
 -1.1716767695713806
  0.18865620373316055

References

Keshavarz Ghorabaee, M., Zavadskas, E. K., Turskis, Z., & Antucheviciene, J. (2016). A new combinative distance-based assessment (CODAS) method for multi-criteria decision-making. Economic Computation & Economic Cybernetics Studies & Research, 50(3), 25-44.

source
codas(setting; tau = 0.02)

Apply CODAS (COmbinative Distance-based ASsessment) method for a given matrix, weights and, type of criteria.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.
  • tau::Float64: tau parameter for the algorithm. The default is 0.02.

Description

codas() applies the CODAS method to rank n alternatives subject to m criteria and criteria type vector.

Output

  • ::CODASResult: CODASResult object that holds multiple outputs including scores and best index.
source

MEREC

JMcDM.MEREC.merec — Function

merec(decisionMat, fns; normalization)

Apply MEREC (MEthod based on the Removal Effects of Criteria) for a given matrix and criteria types.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alternatives and m criteria
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns.
  • normalization{<:Function}: Optional normalization function.

Description

merec() applies the MEREC method to calculate weights using a decision matrix with n alternatives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::MERECResult: MERECResult object that holds multiple outputs including weights.

Examples


julia> decisionMat = DataFrame(
                   :K1 => [450, 10, 100, 220, 5],
                   :K2 => [8000, 9100, 8200, 9300, 8400],
                   :K3 => [54, 2, 31, 1, 23],
                   :K4 => [145, 160, 153, 162, 158]
               )
5×4 DataFrame
 Row │ K1     K2     K3     K4    
     │ Int64  Int64  Int64  Int64 
─────┼────────────────────────────
   1 │   450   8000     54    145
   2 │    10   9100      2    160
   3 │   100   8200     31    153
   4 │   220   9300      1    162
   5 │     5   8400     23    158

julia> fs = [maximum, maximum, minimum, minimum];

julia> result = merec(decisionMat, fs);

julia> result.w
4-element Vector{Float64}:
 0.5752216672093823
 0.01409659116846726
 0.40156136388773117
 0.009120377734419302

References

Keshavarz-Ghorabaee, M., Amiri, M., Zavadskas, E. K., Turskis, Z., & Antucheviciene, J. (2021). Determination of Objective Weights Using a New Method Based on the Removal Effects of Criteria (MEREC). Symmetry, 13(4), 525. https://doi.org/10.3390/sym13040525

source
    merec(setting)

Apply MEREC (MEthod based on the Removal Effects of Criteria) for a given matrix and criteria types.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

merec() applies the MEREC method to rank n alternatives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::MERECResult: MERECResult object that holds multiple outputs including weighting and best index.
source

PIV

JMcDM.PIV.piv — Function
piv(decisionMat, weights, fs; normalization)

Apply PIV (Proximity Indexed Value) method for a given matrix, weights and, type of criteria.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alternatives and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fs::Array{<:Function,1}: m-vector of type of criteria. The benefit criteria shown with "maximum", and the cost criteria shown with "minimum".
  • normalization{<:Function}: Optional normalization function.

Description

piv() applies the PIV method to rank n alternatives subject to m criteria and criteria type vector. Alternatives with lesser scores values (u_i values in the original article) are better as they represent the deviation from the ideal values.

Output

  • ::PIVResult: PIVResult object that holds multiple outputs including scores, rankings, and best index.

References

Sameera Mufazzal, S.M. Muzakkir, A new multi-criterion decision making (MCDM) method based on proximity indexed value for minimizing rank reversals, Computers & Industrial Engineering, Volume 119, 2018, Pages 427-438, ISSN 0360-8352, https://doi.org/10.1016/j.cie.2018.03.045.

source

PSI

JMcDM.PSI.psi — Function
    psi(decisionMat, fns; normalization)

Apply PSI (Preference Selection Index) method for a given matrix and directions of optimizations.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alterntives and m criteria
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns.
  • normalization{<:Function}: Optional normalization function.

Description

psi() applies the PSI method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::PSIResult: PSIResult object that holds multiple outputs including scores, rankings, and best index.

Examples

julia> decmat = [3        12.5        2        120        14        3;
       5        15        3        110        38        4;
       3        13        2        120        19        3;
       4        14        2        100        31        4;
       3        15        1.5        125        40        4]
5×6 Array{Float64,2}:
 3.0  12.5  2.0  120.0  14.0  3.0
 5.0  15.0  3.0  110.0  38.0  4.0
 3.0  13.0  2.0  120.0  19.0  3.0
 4.0  14.0  2.0  100.0  31.0  4.0
 3.0  15.0  1.5  125.0  40.0  4.0



julia> fns = [maximum, minimum, minimum, maximum, minimum, maximum];

julia> result = psi(decmat, fns)
Scores:
[1.1252480520930113, 0.762593438114615, 1.1060476892230147, 1.0059872302387025, 0.7865885089329105]
Ordering: (from worst to best)
[2, 5, 4, 3, 1]
Best indices:
1

julia> result.bestIndex 
1

References

Maniya, Kalpesh, and Mangal Guido Bhatt. "A selection of material using a novel type decision-making method: Preference selection index method." Materials & Design 31.4 (2010): 1785-1789

source
    psi(setting)

Apply PSI (Preference Selection Index) method for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

psi() applies the PSI method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::PSIResult: PSIResult object that holds multiple outputs including scores, rankings, and best index.
source

ROV

JMcDM.ROV.rov — Function
    rov(decisionMat, weights, fns; normalization)

Apply ROV (Range of Value) for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alternatives and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns (directions of optimization).
  • normalization{<:Function}: Optional normalization function.

Description

rov() applies the ROV method to rank n alternatives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::ROVResult: ROVResult object that holds multiple outputs including scores, rankings, and best index.

Examples

julia> mat = [
        0.035 34.5 847 1.76 0.335 0.5 0.59 0.59
        0.027 36.8 834 1.68 0.335 0.665 0.665 0.665
        0.037 38.6 808 2.4 0.59 0.59 0.41 0.5
        0.028 32.6 821 1.59 0.5 0.59 0.59 0.41];


julia>  w = [0.3306, 0.0718, 0.1808, 0.0718, 0.0459, 0.126, 0.126, 0.0472];

julia> fns = [minimum, minimum, minimum, minimum, maximum, minimum, minimum, maximum]

julia> result = rov(mat, w, fns)

julia> result.ranks 

julia> result.scores

References

Madić, Miloš et al. “Application of the ROV method for the selection of cutting fluids.” Decision Science Letters 5 (2016): 245-254.

source

MOOSRA

JMcDM.MOOSRA.moosra — Function
    moosra(decisionMat, weights, fns; lambda = 0.5, normalization)

Apply MOOSRA (Multi-Objective Optimization on the basis of Simple Ratio Analysis) for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alterntives and m criteria
  • weights::Array{Float64, 1}: m-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns.
  • normalization{<:Function}: Optional normalization function.

Description

moosra() applies the MOOSRA method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::MoosraResult: MoosraResult object that holds multiple outputs including scores, rankings, and best index.

Examples

julia> decmat = [3        12.5        2        120        14        3;
       5        15        3        110        38        4;
       3        13        2        120        19        3;
       4        14        2        100        31        4;
       3        15        1.5        125        40        4]
5×6 Array{Float64,2}:
 3.0  12.5  2.0  120.0  14.0  3.0
 5.0  15.0  3.0  110.0  38.0  4.0
 3.0  13.0  2.0  120.0  19.0  3.0
 4.0  14.0  2.0  100.0  31.0  4.0
 3.0  15.0  1.5  125.0  40.0  4.0


julia> weights = [0.221, 0.159, 0.175, 0.127, 0.117, 0.201];

julia> fns = [maximum, minimum, minimum, maximum, minimum, maximum];

julia> result = moosra(decmat, weights, fns, lambda);

References

Das, Manik Chandra, Bijan Sarkar, and Siddhartha Ray. "Decision making under conflicting environment: a new MCDM method." International Journal of Applied Decision Sciences 5.2 (2012): 142-162.

source
    moosra(setting)

Apply MOOSRA (Multi-Objective Optimization on the basis of Simple Ratio Analysis) for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.
source

SD

JMcDM.SD.sd — Function
    sd(decisionMat, fns; normalization)

Apply SD method for a given matrix and directions of optimization.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alternatives and m criteria
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns.
  • normalization{<:Function}: Optional normalization function.

Description

sd() applies the SD method to calculate weights for a set of given criteria.

Output

  • ::SDResult: SDResult object that holds weights.

References

AYDIN, Yüksel. "A hybrid multi-criteria decision making (MCDM) model consisting of SD and COPRAS methods in performance evaluation of foreign deposit banks." Equinox Journal of Economics Business and Political Studies 7.2 (2020): 160-176.

Diakoulaki, Danae, George Mavrotas, and Lefteris Papayannakis. "Determining objective weights in multiple criteria problems: The critic method." Computers & Operations Research 22.7 (1995): 763-770.

source
    sd(setting)

Apply SD method for a given matrix and criteria types.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.
source

SECA

JMcDM.SECA.seca — Function
seca(decisionMat, fns:, beta; epsilon, normalization)

Implement the SECA method for multi-criteria decision making.

Arguments

  • decisionMat::Matrix: A matrix of decision criteria.
  • fns::Array{F,1}: A vector of functions that specifies the Beneficial Criteria (BC) as maximum and the non-Beneficial Criteria (NC) as minimum.
  • beta::Float64: This coefficient affects the importance of reaching the reference points of criteria weights. Note that the output of model is dependent on the value of beta. It's recommended to try several values untill you barely see any change in the weights of each criterion.
  • epsilon::Float64 = 10^-3: a small positive parameter considered as a lower bound for criteria weights.
  • normalization{<:Function}: Optional normalization function.

Description

seca implements the SECA method for multi-criteria decision making and finds the weights of the criteria simultaneously with evaluating the alternatives. The model is based on maximization of the overall performance of alternatives with consideration of the variation information of decision-matrix within and between criteria. seca returns a SecaResult object that contains the decision matrix, weights, scores, and ranks.

Returns

  • SECAResult: A SECAResult object that contains the decision matrix, weights, scores, and ranks.

Example

julia> using JuMP, Ipopt, JMcDM
julia> mat = [
           1.0     0.9925  0.9115  0.8     0.9401  1.0     0.9449;
           0.8696  0.8271  0.8462  1.0     0.9181  0.978   1.0;
           0.7391  0.8684  0.7615  0.2667  0.8177  0.8241  0.8305;
           0.5217  0.7895  0.6654  0.2     0.8051  0.7236  0.8061;
           0.6522  0.9135  0.7692  0.2857  0.8396  0.7063  0.8812;
           0.6087  0.8346  0.7269  0.3077  0.8722  0.6742  0.8926;
           0.913   0.985   0.9346  0.6667  0.9813  0.8641  0.9216;
           0.8696  0.9624  1.0     0.5714  0.9632  0.7807  0.9751;
           0.8261  1.0     0.8077  0.6667  1.0     0.7946  0.9104;
           0.3478  0.8195  0.7462  0.3636  0.8263  0.6642  0.814
       ];

julia> fns = [maximum, minimum, minimum, minimum, minimum, minimum, minimum];

julia> seca(mat, fns, 0.5)
Scores:
[0.5495915719484191, 0.467758585220479, 0.7430581528101969, 0.805136683615562, 0.6786410609782462, 0.6314963009852793, 0.5445938440469921, 0.5570359821894877, 0.509907132860776, 0.4677585801615632]
Ordering:
[6, 9, 2, 1, 3, 4, 7, 5, 8, 10]
Best indice:
4

Reference

Dependencies

This method is enabled when the JuMP and Ipopt packages are installed and loaded.

source

LMAW

JMcDM.LMAW.lmaw — Function
lmaw(decisionMat, weights, fns; normalization)

Apply LMAW (Logarithm Methodology of Additive Weights) for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: m × n matrix of objective values for n alternatives and m criteria
  • weights::Array{Float64, 1}: n-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: n-vector of functions to be applied on the columns.
  • normalization{<:Function}: Optional normalization function.

Description

lmaw() applies the LMAW method to rank m alternatives subject to n criteria which are supposed to be either maximized or minimized.

Output

  • ::LMAWResult: LMAWResult object that holds multiple outputs including scores, rankings, and best index.

Examples

julia> decMat = [
                647.34        6.24        49.87        19.46        212.58        6.75;
                115.64        3.24        16.26         9.69        207.59        3.00;
                373.61        5.00        26.43        12.00        184.62        3.74;
                 37.63        2.48         2.85         9.25        142.50        3.24;
                858.01        4.74        62.85        45.96        267.95        4.00;
                222.92        3.00        19.24        21.46        221.38        3.49
                ]   
       6×6 Matrix{Float64}:
       647.34  6.24  49.87  19.46  212.58  6.75
       115.64  3.24  16.26   9.69  207.59  3.0
       373.61  5.0   26.43  12.0   184.62  3.74
        37.63  2.48   2.85   9.25  142.5   3.24
       858.01  4.74  62.85  45.96  267.95  4.0
       222.92  3.0   19.24  21.46  221.38  3.49

julia> weights = [0.215, 0.126, 0.152, 0.091, 0.19, 0.226];

julia> fns = [maximum, maximum, minimum, minimum, minimum, maximum];

julia> result = lmaw(decmat, weights, fns);

julia> result.scores
6-element Vector{Float64}:
 4.839005264308832
 4.679718180594332
 4.797731427991642
 4.732145373983716
 4.73416833375772
 4.702247270959649

julia> result.bestIndex
1

References

  • Pamučar, D., Žižović, M., Biswas, S., & Božanić, D. (2021). A new logarithm methodology of additive weights (LMAW) for multi-criteria decision-making: Application in logistics. Facta Universitatis, Series: Mechanical Engineering, 19(3), 361. https://doi.org/10.22190/FUME210214031P
source
lmaw(setting)

Apply LMAW (Logarithm Methodology of Additive Weights) for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

lmaw() applies the LMAW method to rank m alternatives subject to n criteria which are supposed to be either maximized or minimized.

Output

  • ::LMAWResult: LMAWResult object that holds multiple outputs including scores, rankings, and best index.
source

LOPCOW

JMcDM.LOPCOW.lopcow — Function
lopcow(decisionMat, fns; normalization)

Apply LOPCOW (LOgarithmic Percentage Change-driven Objective Weighting) method for a given matrix and criteria types.

Arguments:

  • decisionMat::Matrix: n × m matrix of objective values for n alternatives and m criteria
  • fns::Array{<:Function, 1}: m-vector of functions to be applied on the columns.
  • normalization{<:Function}: Optional normalization function.

Description

lopcow() applies the LOPCOW method to calculate objective weights using a decision matrix with n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::LOPCOWResult: LOPCOWResult object that holds multiple outputs including weighting and best index.

Examples


julia> decmat
9×17 Matrix{Float64}:
 21.8  14.1  10.7  1.6  1.8   770.0  12750.0  18.0   5100.0  1.5     9.1    1.054  4.196  29.407   7.03   15.08    9.705
 16.4   8.5  13.9  1.2  1.3   524.0  12087.0   5.7   2941.0  2.208  15.2    1.123  3.86    5.228  14.724  32.103  19.0
 14.5   7.0   2.3  0.2  0.2   238.0   3265.0   1.9    320.0  2.32   16.202  1.008  3.095   5.549  17.34   65.129  32.056
 18.2  10.3  11.4  1.2  1.1   835.0  16037.0  21.3   4332.0  0.875   9.484  0.856  2.191  23.75   13.1    58.157  27.46
 18.5   8.1  11.1  1.0  1.1   504.0   9464.0   1.4   1743.0  2.95    0.7    0.479  2.44    8.77   13.48   33.45   17.68
 18.7  11.4  10.8  1.3  1.5  1227.0  24053.0  20.0   6521.0  0.733   1.6    0.857  2.377   4.985  11.743  26.732  24.485
 18.5  12.6  10.8  1.4  1.8   912.0  18800.0  18.2   5300.0  1.29    8.27   0.558  0.635   5.22   13.829  31.914   7.515
 16.4   6.7  12.6  0.9  0.9   951.0  16767.0  22.0   3917.0  2.46    3.9    0.724  0.568   4.491  14.357  28.869   7.313
 15.2   6.3   6.9  0.5  0.5  1013.0  20170.0  10.97  4060.0  1.67    1.7    0.704  2.96    3.24   10.029  60.981  23.541

julia> fns = [maximum, maximum, maximum, maximum, maximum, maximum, maximum, maximum, maximum, maximum, minimum, minimum, minimum, minimum, minimum, minimum, minimum ];

julia> result = lopcow(decmat, fns);

julia> result.w
17-element Vector{Float64}:
 0.04947396185854988
 0.036623078374935315
 0.08456624432002027
 0.07055941647198624
 ⋮
 0.07625360895444118
 0.05507171491276535
 0.05320727577078255
 0.05340460620185558

References

Ecer, F., & Pamucar, D. (2022). A novel LOPCOW‐DOBI multi‐criteria sustainability performance assessment methodology: An application in developing country banking sector. Omega, 112, 102690. https://doi.org/10.1016/j.omega.2022.102690

source
lopcow(setting)

Apply LOPCOW (LOgarithmic Percentage Change-driven Objective Weighting) method for a given matrix and criteria types.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

lopcow() applies the LOPCOW method to rank n alterntives subject to m criteria which are supposed to be either maximized or minimized.

Output

  • ::LOPCOWResult: LOPCOWResult object that holds multiple outputs including weighting and best index.
source

OCRA

JMcDM.OCRA.ocra — Function
ocra(decisionMat, weights, fns)

Apply OCRA (Operational Competitiveness RAting) for a given matrix and weights.

Arguments:

  • decisionMat::Matrix: m × n matrix of objective values for n alternatives and m criteria
  • weights::Array{Float64, 1}: n-vector of weights that sum up to 1.0. If the sum of weights is not 1.0, it is automatically normalized.
  • fns::Array{<:Function, 1}: n-vector of functions to be applied on the columns.

Description

ocra() applies the OCRA method to rank m alternatives subject to n criteria which are supposed to be either maximized or minimized.

Output

  • ::OCRAResult: OCRAResult object that holds multiple outputs including scores, rankings, and best index.

Examples

julia> decMat = [
            8.0  16.0  1.5  1.2   4200.0  5.0  5.0  314.0  185.0;
            8.0  16.0  1.0  1.3   4200.0  5.0  4.0  360.0  156.0;
           10.1  16.0  2.0  1.3   4060.0  5.0  3.0  503.0  160.0;
           10.1   8.0  1.0  1.5   5070.0  2.0  4.0  525.0  200.0;
           10.0  16.0  2.0  1.2   6350.0  5.0  3.0  560.0  190.0;
           10.1  16.0  1.0  1.2   5500.0  2.0  2.0  521.0  159.0;
           10.1  64.0  2.0  1.7   5240.0  5.0  3.0  770.0  199.0;
            7.0  32.0  1.0  1.8   3000.0  3.0  4.0  364.0  157.0;
           10.1  16.0  1.0  1.3   3540.0  5.0  3.0  510.0  171.0;
            9.7  16.0  2.0  1.83  7500.0  6.0  2.0  550.0  170.0
       ]
10×9 Matrix{Float64}:
  8.0  16.0  1.5  1.2   4200.0  5.0  5.0  314.0  185.0
  8.0  16.0  1.0  1.3   4200.0  5.0  4.0  360.0  156.0
 10.1  16.0  2.0  1.3   4060.0  5.0  3.0  503.0  160.0
 10.1   8.0  1.0  1.5   5070.0  2.0  4.0  525.0  200.0
 10.0  16.0  2.0  1.2   6350.0  5.0  3.0  560.0  190.0
 10.1  16.0  1.0  1.2   5500.0  2.0  2.0  521.0  159.0
 10.1  64.0  2.0  1.7   5240.0  5.0  3.0  770.0  199.0
  7.0  32.0  1.0  1.8   3000.0  3.0  4.0  364.0  157.0
 10.1  16.0  1.0  1.3   3540.0  5.0  3.0  510.0  171.0
  9.7  16.0  2.0  1.83  7500.0  6.0  2.0  550.0  170.0

julia> weights =[0.167, 0.039, 0.247, 0.247, 0.116, 0.02, 0.056, 0.027, 0.081];

julia> fns = [maximum,maximum,maximum,maximum,maximum,maximum,maximum,minimum,minimum];

julia> result = ocra(decmat, weights, fns);

julia> result.scores
10-element Vector{Float64}:
 0.14392093908214929
 0.024106550710436096
 0.27342011595623067
 0.04297916544177691
 0.31851953804157623
 0.0024882426914910674
 0.5921715172301161
 0.11390289470614312
 0.0
 0.47874854984718046

julia> result.bestIndex
7

References

  • Parkan, C. (1994). Operational competitiveness ratings of production units. Managerial and Decision Economics, 15(3), 201–221. doi:10.1002/mde.4090150303 
  • Parkan, C. (2003). Measuring the effect of a new point of sale system on the performance of drugstore operations. Computers & Operations Research, 30(5), 729–744. doi:10.1016/s0305-0548(02)00047-3 
  • Kundakcı, N. (2017). An Integrated Multi-Criteria Decision Making Approach for Tablet Computer Selection. European Journal of Multidisciplinary Studies, 2(5), 31-43.
source
ocra(setting)

Apply OCRA (Operational Competitiveness RAting) for a given matrix and weights.

Arguments:

  • setting::MCDMSetting: MCDMSetting object.

Description

ocra() applies the OCRA method to rank m alternatives subject to n criteria which are supposed to be either maximized or minimized.

Output

  • ::OCRAResult: OCRAResult object that holds multiple outputs including scores, rankings, and best index.
source

TODIM

JMcDM.TODIM.todim — Function
todim(decisionMat::Matrix, weights::Vector, fns::Array{F,1})::TODIMResult where F<:Function

Run TODIM method for a given desicion matrix, criteria weights and identity of criteria.

Arguments

  • decisionMat::Matrix: A matrix of decision criteria. It's assumed that the criteria are

in the columns and alternatives are in the rows.

  • weights::Vector: A vector of weights of criteria.
  • fns::Array{F,1}: A vector of functions that specifies the Beneficial Criteria (BC) as

maximum and the non-Beneficial Criteria (NC) as minimum.

Keyword Arguments

  • normalization{<:Function}: Optional normalization function. Default is min-max normalization (available as Normalizations.maxminrangenormalization).

Returns

  • TODIMResult: A TODIMResult object that holds multiple outputs including scores and best

index.

Example

julia> mat = [
           1.0     0.9925;
           0.8696  0.8271;
           0.7391  0.8684;
           0.5217  0.7895;
           0.6522  0.9135;
           0.6087  0.8346;
           0.913   0.185
       ];

julia> fns = [maximum, minimum];

julia> w = [2, 3];

julia> result = todim(mat, w, fns)
TODIMResult([1.0 0.9925; 0.8696 0.8271; … ; 0.6087 0.8346; 0.913 0.185], [2.0, 3.0], [1.0, 0.4285714285714285, 0.5952380952380951, 0.0, 0.5714285714285714, 0.30952380952380953, 0.3095238095238094], [1, 3, 5, 2, 6, 7, 4], 1)

References

  1. Gomes, L. F. A. M., & Lima, M. M. P. P. (1991). TODIMI: Basics and application to multicriteria ranking. Found. Comput. Decis. Sci, 16(3-4), 1-16.

  2. Alali, F., & Tolga, A. C. (2019). Portfolio allocation with the TODIM method. Expert Systems with Applications, 124, 341-348.

source