# mma

0th

Percentile

##### Method of Moving Asymptotes

Globally-convergent method-of-moving-asymptotes (MMA) algorithm for gradient-based local optimization, including nonlinear inequality constraints (but not equality constraints).

##### Usage
mma(x0, fn, gr = NULL, lower = NULL, upper = NULL, hin = NULL,
hinjac = NULL, nl.info = FALSE, control = list(), ...)
##### Arguments
x0

starting point for searching the optimum.

fn

objective function that is to be minimized.

gr

gradient of function fn; will be calculated numerically if not specified.

lower, upper

lower and upper bound constraints.

hin

function defining the inequality constraints, that is hin>=0 for all components.

hinjac

Jacobian of function hin; will be calculated numerically if not specified.

nl.info

logical; shall the original NLopt info been shown.

control

list of options, see nl.opts for help.

...

additional arguments passed to the function.

##### Details

This is an improved CCSA ("conservative convex separable approximation") variant of the original MMA algorithm published by Svanberg in 1987, which has become popular for topology optimization. Note:

##### Value

List with components:

par

the optimal solution found so far.

value

the function value corresponding to par.

iter

number of (outer) iterations, see maxeval.

convergence

integer code indicating successful completion (> 1) or a possible error number (< 0).

message

character string produced by NLopt and giving additional information.

##### Note

Globally convergent'' does not mean that this algorithm converges to the global optimum; it means that it is guaranteed to converge to some local minimum from any feasible starting point.

##### References

Krister Svanberg, A class of globally convergent optimization methods based on conservative convex separable approximations,'' SIAM J. Optim. 12 (2), p. 555-573 (2002).

slsqp

• mma
##### Examples
# NOT RUN {
##  Solve the Hock-Schittkowski problem no. 100 with analytic gradients
x0.hs100 <- c(1, 2, 0, 4, 0, 1, 1)
fn.hs100 <- function(x) {
(x-10)^2 + 5*(x-12)^2 + x^4 + 3*(x-11)^2 + 10*x^6 +
7*x^2 + x^4 - 4*x*x - 10*x - 8*x
}
hin.hs100 <- function(x) {
h <- numeric(4)
h <- 127 - 2*x^2 - 3*x^4 - x - 4*x^2 - 5*x
h <- 282 - 7*x - 3*x - 10*x^2 - x + x
h <- 196 - 23*x - x^2 - 6*x^2 + 8*x
h <- -4*x^2 - x^2 + 3*x*x -2*x^2 - 5*x	+11*x
return(h)
}
gr.hs100 <- function(x) {
c(  2 * x -  20,
10 * x - 120,
4 * x^3,
6 * x - 66,
60 * x^5,
14 * x   - 4 * x - 10,
4 * x^3 - 4 * x -  8 )}
hinjac.hs100 <- function(x) {
matrix(c(4*x, 12*x^3, 1, 8*x, 5, 0, 0,
7, 3, 20*x, 1, -1, 0, 0,
23, 2*x, 0, 0, 0, 12*x, -8,
8*x-3*x, 2*x-3*x, 4*x, 0, 0, 5, -11), 4, 7, byrow=TRUE)
}

# incorrect result with exact jacobian
S <- mma(x0.hs100, fn.hs100, gr = gr.hs100,
hin = hin.hs100, hinjac = hinjac.hs100,
nl.info = TRUE, control = list(xtol_rel = 1e-8))

# }
# NOT RUN {
# This example is put in donttest because it runs for more than
# 40 seconds under 32-bit Windows. The difference in time needed
# to execute the code between 32-bit Windows and 64-bit Windows
# can probably be explained by differences in rounding/truncation
# on the different systems. On Windows 32-bit more iterations
# are needed resulting in a longer runtime.
# correct result with inexact jacobian
S <- mma(x0.hs100, fn.hs100, hin = hin.hs100,
nl.info = TRUE, control = list(xtol_rel = 1e-8))
# }
# NOT RUN {
# }

Documentation reproduced from package nloptr, version 1.2.1, License: LGPL-3

### Community examples

Looks like there are no examples yet.