fminSLSQP

Syntax

fminSLSQP(func, X0, [fprime], [constraints], [bounds], [ftol=1e-6], [epsilon], [maxIter=100]))

Arguments

func is the function to minimize. The return value of the function must be numeric type.

X0 is a numeric scalar or vector indicating the initial guess.

fprime (optional) is the gradient of func. If not provided, then func returns the function value and the gradient.

constraints (optional) is a vector of dictionaries. Each dictionary should include the following members:

  • type: A string indicating the constraint type, which can be ‘eq’ for equality constraints and ‘ineq’ for inequality constraints.

  • fun: The constraint function.

  • jac: The gradient function of constraint fun.

bounds (optional) is a numeric matrix indicating the bounds on parameters of X0. The matrix must be in the shape of (N,2), where N=size(X0). The two elements of each row defines the bounds (min, max) on that parameter. float("inf") can be specified for no bound in that direction.

ftol (optional) is a positive number indicating the precision requirement for the function value when the optimization stops. The default value is 1e-6.

epsilon (optional) is a positive number indicating the step size used for numerically calculating the gradient. The default value is 1.4901161193847656e-08.

maxIter (optional) is a non-negative integer indicating the maximum number of iterations. The default value is 15000.

Details

Minimize a function using Sequential Least Squares Programming.

Return value: A dictionary with the following members:

  • xopt: A floating-point vector indicating the parameters of the minimum.

  • fopt: A floating-point scalar indicating the value of func at the minimum, i.e., fopt=func(xopt).

  • iterations: Number of iterations.

  • mode: An integer indicating the optimization state. mode=0 means optimization succeeded, while other values indicate abnormal algorithm termination.

Examples

Minimize function rosen using Sequential Least Squares Programming:

def rosen(x) { 
	N = size(x);
	return sum(100.0*power(x[1:N]-power(x[0:(N-1)], 2.0), 2.0)+power(1-x[0:(N-1)], 2.0));
}

def rosen_der(x) {
	N = size(x);
	xm = x[1:(N-1)]
	xm_m1 = x[0:(N-2)]
	xm_p1 = x[2:N]
	der = array(double, N)
	der[1:(N-1)] = (200 * (xm - xm_m1*xm_m1) - 400 * (xm_p1 - xm*xm) * xm - 2 * (1 - xm))
	der[0] = -400 * x[0] * (x[1] - x[0]*x[0]) - 2 * (1 - x[0])
	der[N-1] = 200 * (x[N-1] - x[N-2]*x[N-2])
	return der
}

def eq_fun(x) {
	return 2*x[0] + x[1] - 1
}

def eq_jac(x) {
	return [2.0, 1.0]
}

def ieq_fun(x) {
	return [1 - x[0] - 2*x[1], 1 - x[0]*x[0] - x[1], 1 - x[0]*x[0] + x[1]]
}

def ieq_jac(x) {
	ret = matrix(DOUBLE, 2, 3)
	ret[0,:] = [-1.0, -2*x[0], -2*x[0]]
	ret[1,:] = [-2.0, -1.0, 1.0]
	return ret
}

eqCons=dict(STRING, ANY)
eqCons[`type]=`eq
eqCons[`fun]=eq_fun
eqCons[`jac]=eq_jac

ineqCons=dict(STRING, ANY)
ineqCons[`type]=`ineq
ineqCons[`fun]=ieq_fun
ineqCons[`jac]=ieq_jac

cons = [eqCons, ineqCons]

X0 = [0.5, 0]
bounds = matrix([0 -0.5, 1.0 2.0])
res = fminSLSQP(rosen, X0, rosen_der, cons, bounds, 1e-9)
res;

Output:

mode->0
xopt->[0.414944749170,0.170110501659]
fopt->0.342717574994
iterations->4