Description Usage Arguments Value Note Examples

View source: R/findLocallyEfficientPoint.R

Performs sequential downhill steps in the direction of the multi-objective gradient
until a locally efficient point was found. The latter possess a multi-objective
gradient of length zero (see `performGradientStep`

for details) as the
normalized gradients of its objectives cancel each other out.

Note that once the local search detects that it crossed the optimum (i.e., the
multi-objective gradients of succeeding iterations show in opposite directions),
it will perform a weighted bisection optimization to find a local efficient point.
See `performWeightedBisectionOptimization`

for further details on the
latter.

1 2 3 4 5 |

`ind` |
[ |

`fn1` |
[ |

`fn2` |
[ |

`gradient.list` |
[ |

`max.no.steps.ls` |
[ |

`scale.step` |
[ |

`prec.grad` |
[ |

`prec.norm` |
[ |

`prec.angle` |
[ |

`ls.method` |
[ |

`lower` |
[ |

`upper` |
[ |

`check.data` |
[ |

`show.info` |
[ |

`allow.restarts` |
[ |

[`list(3L)`

]

Returns a list, whose first element (`opt.path`

) provides the matrix
of the optimization path, which has been evaluated on the way to a locally
efficient point. As the 1st row represents the initial individual
(`ind`

), the i-th row corresponds to the (i-1)-th individual.

The second element of the list (`fn.evals`

) contains a matrix with
the corresponding number of function evaluations per objective. As a
result, this matrix consists of `p`

columns and as many rows as
`opt.path`

.

The final list element (`gradient.list`

) provides another list, whose
`p`

elements provide the single-objective gradients of the last
individual from `opt.path`

. This information might be used to safe
function evaluations when proceeding with that particular individual
(e.g., when exploring a potential existing efficient set).

ATTENTION: Only turn off the sanity checks (`check.data = FALSE`

),
if you can ensure that all input parameters are provided in the correct format.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ```
# Define two single-objective test problems:
fn1 = function(x) sum((x - c(2, 0))^2)
fn2 = function(x) sum((x - c(0, 1))^2)
# Visualize locally efficient set, i.e., the "area" where we ideally want to find a point:
plot(c(2, 0), c(0, 1), type = "o", pch = 19,
xlab = expression(x[1]), ylab = expression(x[2]), las = 1, asp = 1)
text(2, 0, "Optimum of fn1", pos = 2, offset = 1.5)
text(0, 1, "Optimum of fn2", pos = 4, offset = 1.5)
# Place two points x1 and x2 on opposite sides of the bi-objective optimum:
x.start = c(0.3, 0.5)
points(rbind(x.start), pch = 19, type = "o", lty = "dotted")
text(rbind(x.start), labels = c("start"), pos = 2)
# Visualize path of bisection search in blue
res.bisection = findLocallyEfficientPoint(c(0.3, 0.5), fn1, fn2, ls.method = "bisection")
points(res.bisection$opt.path, pch = 20, lty = 2, type = "o", col = "blue")
# Visualize path of multi-objective local search in red
res.mo.ls = findLocallyEfficientPoint(c(0.3, 0.5), fn1, fn2, ls.method = "mo-ls")
points(res.mo.ls$opt.path, pch = 20, lty = 2, type = "o", col = "red")
``` |

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.