Pairwise Comparison Matrix Creation

The pairwise comparison matrix can either be loaded from a file or inputed manually. Since the version 0.6.9 the values can be represented as either character or double. However, the character representation seem as slightly better idea because it allows printing more comprehensible output. The matrix needs to be squared reciprocal matrix with maximal value smaller or equall to 9.

The matrix in text file can have the following form.

;"crit1";"crit2";"crit3"
"crit1";"1";"9";"5" 
"crit2";"1/9";"1";"1/3"
"crit3";"1/5";"3";"1"

The loading is then done as:

matrixFile =  "comparison_matrix.csv"
comparisonMatrix = read.csv(matrixFile, sep = ";",
                   stringsAsFactors = FALSE, header = TRUE, row.names = 1, strip.white = TRUE)
comparisonMatrix = as.matrix(comparisonMatrix)

If the matrix is inputed manually then it can be done by following commands:

comparisonMatrixValues = c(1,9,5,
                           1/9,1,1/3,
                           1/5,3,1)
comparisonMatrix = matrix(comparisonMatrixValues, nrow = 3, ncol = 3, byrow = TRUE)

In the case that the values are represented as double. If the values are represented as character then the code looks like this:

comparisonMatrixValues = c("1","9","5",
                           "1/9","1","1/3",
                           "1/5","3","1")
comparisonMatrix = matrix(comparisonMatrixValues, nrow = 3, ncol = 3, byrow = TRUE)

Either way the comparsion matrix is created using command pairwiseComparisonMatrix. After printing we can see that the S4 object contains two representation of the matrix, One as characters and other one as numeric.

comparisonMatrix = pairwiseComparisonMatrix(comparisonMatrix)
print(comparisonMatrix)

##      [,1]  [,2] [,3] 
## [1,] "1"   "9"  "5"  
## [2,] "1/9" "1"  "1/3"
## [3,] "1/5" "3"  "1"

CR = consistencyRatio(comparisonMatrix)

## Consistency ratio is: 0.0279459296138796. The pairwise comparison matrix is consistent for calculations.

weakConsistency = weakConsistency(comparisonMatrix)

## The comparison matrix is weakly consistent.

strictConsistency = strictConsistency(comparisonMatrix)

## Comparison matrix isn't strictly consistent. These indeces violate the condition: 
## [1,3] != ([1,2]*[2,3]) -- 5 != 3
## [1,2] != ([1,3]*[3,2]) -- 9 != 15
## [2,3] != ([2,1]*[1,3]) -- 0.333333333333333 != 0.555555555555556
## [2,1] != ([2,3]*[3,1]) -- 0.111111111111111 != 0.0666666666666667
## [3,2] != ([3,1]*[1,2]) -- 3 != 1.8
## [3,1] != ([3,2]*[2,1]) -- 0.2 != 0.333333333333333

Calculations with Pairwise Comparison Matrix

If the matrix is consistent for calculation accoring to users conditions subsequent calculations can be made. First step is obtaining weights of criteria. The weights are calculated as geometric mean of each row of the pairwise comparison matrix.

weights = calculateWeights(comparisonMatrix)
print(weights)

##     w1     w2     w3 
## 0.7514 0.0704 0.1782

To calculate the AHP some data are needed. As mentioned in the description the FuzzyAHP package is prepared for data that uses scale (categorical) ranking of alternatives (the higher the value the better). In order to calculate AHP we need matrix of data that has the same number of colums as there are weights.

Data that have even one element equal to NA are to taken into account at all, the result is automatically determined as NA.

values = c(4,5,3,
1,3,9,
8,6,4,
3,2,7,
6,7,5,
4,5,3,
NA,9,9,
NA,NA,NA)
values = matrix(values, nrow = length(values)/length(weights@weights), ncol = length(weights@weights), byrow = TRUE)

Now we can calculate the result according to the weights. The values with higher resulting value are better solutions of the AHP problem.

result = calculateAHP(weights, values)
print(result)

##        result
## [1,] 3.892240
## [2,] 2.566257
## [3,] 7.146454
## [4,] 3.642293
## [5,] 5.892240
## [6,] 3.892240
## [7,]       NA
## [8,]       NA

If we wan to rank solutions from the best to the worst, we can do that.

rank = compareResults(result)
print(rank)

##      [,1]
## [1,]    5
## [2,]    8
## [3,]    3
## [4,]    7
## [5,]    4
## [6,]    5
## [7,]   NA
## [8,]   NA

It is also possible to put the results together to produce better outcome.

result = cbind(values, result, rank)
colnames(result) = c("crit1", "crit2", "crit3", "result_value", "ranking")
print(result)

##      crit1 crit2 crit3 result_value ranking
## [1,]     4     5     3     3.892240       5
## [2,]     1     3     9     2.566257       8
## [3,]     8     6     4     7.146454       3
## [4,]     3     2     7     3.642293       7
## [5,]     6     7     5     5.892240       4
## [6,]     4     5     3     3.892240       5
## [7,]    NA     9     9           NA      NA
## [8,]    NA    NA    NA           NA      NA

Obviously, since AHP is a hierarchical process the result from one calculation can be merged with outcomes from another calculation (ie. using cbind command) and used as input to another AHP calculation.

Fuzzy Pairwise Comparison Matrix Creation

The fuzzy pairwise comparison matrix is an extended version of pairwise comparison matrix constructed with respect to fuzzy scale. Details about fuzzy AHP are provided in several articles by Laarhoven and Pedrycz (1983) and Chang (1996).

comparisonMatrixValues = c("1","9","5",
                       "1/9","1","1/3",
                       "1/5","3","1")
comparisonMatrix = matrix(comparisonMatrixValues, nrow = 3, ncol = 3, byrow = TRUE)
comparisonMatrix = pairwiseComparisonMatrix(comparisonMatrix)

Due to the fact, that checking of fuzzy comparsion matrix consistency is relatively complicated, it is simpler to check the non fuzzy matrix and assume that if non fuzzy matrix is consistend than so is the fuzzy matrix. The checks are described above.

The comparison matrix is fuzzified with respect to the fuzzy scale. Default fuzzy scale ranging from 1 to 9 with width of fuzzy number equal to 2 is provided. However, user can specify his own fuzzy scale. For the details please see documentation.

fuzzyComparisonMatrix = fuzzyPairwiseComparisonMatrix(comparisonMatrix)
print(fuzzyComparisonMatrix)

##      [,1]                    [,2]      [,3]               
## [1,] "(1;1;1)"               "(8;9;9)" "(4;5;6)"          
## [2,] "(0.1111;0.1111;0.125)" "(1;1;1)" "(0.25;0.3333;0.5)"
## [3,] "(0.1667;0.2;0.25)"     "(2;3;4)" "(1;1;1)"

Calculations with Fuzzy Pairwise Comparison Matrix

With the fuzzy comparion matrix the result of AHP process can be calculated in the same way as with classic comparison matrix. The weights of fuzzy comparison matrix are calculated by approach desribed by Krejčí, Pavlačka, and Talašová (2016).

result = calculateAHP(fuzzyComparisonMatrix, values)

The resulting values have issue of representing uncertaint value. Such values are hard to present to user directly. Even though it is possible. The user can extract singe fuzzy numbers from the set.

fuzzyNumer = getFuzzyNumber(result, as.integer(2))
print(fuzzyNumer)

##      minimal    modal  maximal
## [1,] 2.17584 2.566257 3.055858

It might be reasonable for user to either defuzzify the values into single output or rank then using fuzzy ranking methods. Defuzzification can be done using several approaches, here Yager’s index is used as described by Tesfamariam and Sadiq (2006). The results of defuzzification can be ranked as classic results of AHP.

defuzzified = defuzziffy(result, "Yager")
print(defuzzified)

##          [,1]
## [1,] 3.897250
## [2,] 2.599318
## [3,] 7.135438
## [4,] 3.654089
## [5,] 5.899425
## [6,] 3.897250
## [7,]       NA
## [8,]       NA

rank = (nrow(values)+1) - rank(defuzzified, na.last = FALSE, ties.method= "max")
print(rank)

## [1] 3 6 1 5 2 3 8 7

Ranking of fuzzy numbers can be done using various approaches. One of them is Chen’s method described by Tesfamariam and Sadiq (2006).

ranked = compareFuzzyNumbers(result, "Chen")
print(ranked)

##           [,1]
## [1,] 0.3241398
## [2,] 0.1067964
## [3,] 0.8682673
## [4,] 0.2849724
## [5,] 0.6625851
## [6,] 0.3241398
## [7,]        NA
## [8,]        NA

Another possibility is the utilization of possibility theory as described by Dubois and Prade (1983). These indices work very well if there is a relatively bigger set of very good solutions. Unlike defuzzification or other methods these indices can rank them very well. However, if there is only one dominant best solution the result might not be very descriptive.

For large datasets the calculation might take a while. Because of that a graphical progressbar can be printed if it is turn on by progressBar parameter.

ranked = compareFuzzyNumbers(result, "possibilityTheory")
# ranked = compareFuzzyNumbers(result, "possibilityTheory", progressBar = TRUE)

print(ranked)

##      possiblity necessity
## [1,]          0         0
## [2,]          0         0
## [3,]          1         1
## [4,]          0         0
## [5,]          0         0
## [6,]          0         0
## [7,]         NA        NA
## [8,]         NA        NA