Parameter Constraints

Chapter Contents

Nonlinear Optimization Examples

Parameter Constraints

You can specify constraints in the following ways:

The matrix input argument "blc" enables you to specify boundary and general linear constraints.
The IML module input argument "nlc" enables you to specify general constraints, particularly nonlinear constraints.

Specifying the BLC Matrix

The input argument "blc" specifies an n₁ ×n₂ constraint matrix, where n₁ is two more than the number of linear constraints, and n₂ is given by

$n2 = \{ n & {if 1 \leq n1 \leq 2} \ n+2 & {if n1 \gt 2} .$

The first two rows define lower and upper bounds for the n parameters, and the remaining c=n₁-2 rows define general linear equality and inequality constraints. Missing values in the first row (lower bounds) substitute for the largest negative floating point value, and missing values in the second row (upper bounds) substitute for the largest positive floating point value. Columns n+1 and n+2 of the first two rows are not used.

The following c rows of the "blc" argument specify c linear equality or inequality constraints:

$\sum_{j=1}^n a_{ij} x_j (\leq | = | \geq) b_i , i=1, ... ,c$

Each of these c rows contains the coefficients a_ij in the first n columns. Column n+1 specifies the kind of constraint, as follows:

blc[n+1]= 0 indicates an equality constraint.
blc[n+1]= 1 indicates a $\ge$ inequality constraint.
blc[n+1]= -1 indicates a $\le$ inequality constraint.

Column n+2 specifies the right-hand side, b_i. A missing value in any of these rows corresponds to a value of zero.

For example, suppose you have a problem with the following constraints on x₁,x₂, x₃, x₄:

$2 & \le & x_1 & \le & 100 \ & & x_2 & \le & 40 \0 & \le & x_4 & \$

$4x_1 & + & 3x_2 & - & x_3 & & & \le & 30 \ & & x_2 & & & + & 6x_4 & \ge & 17 \ x_1 & - & x_2 & & & & & = & 8 \$

The following statements specify the matrix CON, which can be used as the "blc" argument to specify the preceding constraints:

   proc iml;
      con = {   2   .   .   0    .    . ,
              100  40   .   .    .    . ,
                4   3  -1   .   -1   30 ,
                .   1   .   6    1   17 ,
                1  -1   .   .    0    8   };

Specifying the NLC and JACNLC Modules

The input argument "nlc" specifies an IML module that returns a vector, c, of length nc, with the values, c_i, of the nc linear or nonlinear constraints

$c_i(x) & = & 0 , i=1, ... ,nec, \c_i(x) & \geq & 0 , i=nec+1, ... ,nc,$

for a given input parameter point x.

Note: You must specify the number of equality constraints, nec, and the total number of constraints, nc, returned by the "nlc" module to allocate memory for the return vector. You can do this with the opt[11] and opt[10] arguments, respectively.

For example, consider the problem of minimizing the objective function f(x₁,x₂) = x₁x₂ in the interior of the unit circle, $x_1^2 + x_2^2 \leq 1$ . The constraint can also be written as $c_1(x) = 1 - x_1^2 - x_2^2 \ge 0$ . The following statements specify modules for the objective and constraint functions and call the NLPNMS subroutine to solve the minimization problem:

   proc iml;
      start F_UC2D(x);
         f = x[1] * x[2];
         return(f);
      finish F_UC2D;

      start C_UC2D(x);
         c = 1. - x * x`;
         return(c);
      finish C_UC2D;

      x = j(1,2,1.);
      optn= j(1,10,.); optn[2]= 3; optn[10]= 1;
      CALL NLPNMS(rc,xres,"F_UC2D",x,optn) nlc="C_UC2D";

To avoid typing multiple commas, you can specify the "nlc" input argument with a keyword, as in the preceding code. The number of elements of the return vector is specified by OPTN[10]=1. There is a missing value in OPTN[11], so the subroutine assumes there are zero equality constraints.

The NLPQN algorithm uses the nc ×n Jacobian matrix of first-order derivatives

$( \nabla_x c_i(x) ) = ( \frac{\partial c_i}{\partial x_j} ) , i= 1, ... ,nc, j=1, ... ,n$

of the nc equality and inequality constraints, c_i, for each point passed during the iteration. You can use the "jacnlc" argument to specify an IML module that returns the Jacobian matrix JC. If you specify the "nlc" module without using the "jacnlc" argument, the subroutine uses finite difference approximations of the first-order derivatives of the constraints.

Note: The COBYLA algorithm in the NLPNMS subroutine and the NLPQN subroutine are the only optimization techniques that enable you to specify nonlinear constraints with the "nlc" input argument.

Chapter Contents
Previous
Next
Top