AHP File Format

Alternatives

On the leaf criteria, you add the alternatives, using the YAML reference feature:

Goal:
  name: Vacation
  children:
    Costs:
      children: *alternatives
    Fun:
      children: *alternatives
    Spa:
      children: *alternatives

Decision Makers

In case you have multiple decision makers, you need an additional layer. For example:

preferences:
  Dad:
    pairwise:
      ...
  Mom:
    score:
      ...
  Kid:
    scoreFun:
      ...

Note that, in case you have specified decision-makers section(s), the names must match.

pairwise

If you are an AHP purist, this is the only preference type you’ll ever need. It lets you define the pairwise preferences amongst all the sub-criteria or alternatives below a specific node. Each pairwise preference is of the form:

- [option1, option2, pairwise preference]

For example:

Goal:
  name: Vacation
  preferences:
    pairwise:
    - [Costs, Fun, 4]
    - [Costs, Spa, 9]
    - [Spa, Fun, 1/4]
  children:
    Costs:
    Fun:
    Spa:

Note, again, that you can enter numbers (4, 9), or expressions that evaluate to a number in R (e.g. 1/4).

The values are typically from 1/9 to 9, where 1/9 means option2 is highly preferrable over option1, while 9 means option1 is highly preferrable over option2. However, you may customize this behaviour using the pairwiseFun parameter of the Calculate method.

The standard function used to convert pairwise to priority is the Eigenvalue method. See ?PrioritiesFromPairwiseMatrixEigenvalues for more details. Two other options contained in the package are the mean normalization, PrioritiesFromPairwiseMatrixMeanNormalization, and the geometric mean PrioritiesFromPairwiseMatrixGeometricMean. If you want to customize this behaviour, you need to write your own function. The requirement for such a function is that it needs to take a pairwise preference matrix as its first argument.

pairwiseFunction

Instead of spelling out all pairwise preferences explicitly, you may prefer to define an R function that calculates the pairwise preferences for you, based on the alternatives attributes. For example, if your alternatives are:

Alternatives: &alternatives
  Beach:
    cost: 10000
  Mountains:
    cost: 5000

Then, you could define a pairwiseFunction as follows:

Costs:
  preferences:
    pairwiseFunction: 
      function(a1, a2) min(9, max(1/9, a2$cost/a1$cost))

The Calculate process will then go over all alternatives, and call the function for each pairwise combination. The result of the function is then directly written into the pairwise element.

A function can also span multiple lines, by using the > character:

Costs:
  preferences:
    pairwiseFunction: >
      function(a1, a2) {
        min(9, max(1/9, a2$cost/a1$cost))
      }

Additionally, the function does not have to be anonymous. If it is named, you can reference it recursively, e.g.

Costs:
  preferences:
    pairwiseFunction: >
      CostFunction <- function(a1, a2) {
        if (a1$cost < a2$cost) return (CostFunction(a2, a1))
        min(9, a1$cost/a2$cost)
      }

score

Purists will not approve of this, but in practice, this can be very handy: Defining pairwise preferences, especially for many alternatives, becomes cumbersome quickly. Instead, you can define a score. Then, instead of using the Eigenvalues to derive priorities from the pairwise preference matrix, Calculate will directly use the scores.

With the default behaviour, a score that’s n times higher will lead to a n times higher priority. However, you can change that behaviour by setting the scoresFun argument of the Calculate function.

For example, if you have three alternatives, and scores are 2, 5, and 10, then you will get priorities of 0.125, 0.1875 and 0.6875, respectively.

Another advantage of scores is that you can assign a score of 0, leading to a priority of 0.

You can define scores like this:

Fun:
  preferences:
    score:
      - Beach: 5
      - Mountains: 0

scoreFunction

Similarly to the pairwiseFunction, you can derive the score via a function, defined directly in the ahp file. The difference is that, here, your function must have a single argument. For example:

Costs:
  preferences:
    scoreFunction:
      function(alternative) alternative$cost

priority

The priority is the scaled / normalized weight you attribute to each sub-criteria or alternative. Typically, the priority is calculated directly by the Calcualte function. However, at some times it is convenient to define the priorities directly, in the file.

The priority is defined similarly to the score, but it must sum up to 1.

For example:

Costs:
  preferences:
    priority:
      - Beach: 1/2
      - Mountains: 1/2

weightContribution

The weightContribution is the final result of the Calculate method. It is the contribution of a criteria to an alternative’s overall priority.