linLsqLinConstraints¶

Solves a linear least-squares problem with linear constraints.

Synopsis¶

linLsqLinConstraints (a,  b,  c,  bl,  bu,  conType,  xlb,  xub)

Required Arguments¶

float a[[]] (Input): Array of size nra × nca containing the coefficients of the nra least-squares equations.
float b[] (Input): Array of length nra containing the right-hand sides of the least-squares equations.
float c[[]] (Input): Array of size ncon × nca containing the coefficients of the ncon constraints.
float bl[] (Input): Array of length ncon containing the lower limit of the general constraints. If there is no lower limit on the i‑th constraint, then bl[i] will not be referenced.
float bu[] (Input): Array of length ncon containing the upper limit of the general constraints. If there is no upper limit on the i‑th constraint, then bu[i] will not be referenced. If there is no range constraint, bl and bu can share the same storage.
int conType[] (Input): Array of length ncon indicating the type of constraints exclusive of simple bounds, where conType[i] = 0, 1, 2, 3 indicates =, <=, >= and range constraints, respectively.
float xlb[] (Input): Array of length nca containing the lower bound on the variables. If there is no lower bound on the i‑th variable, then xlb[i] should be set to 1.0e30.
float xub[] (Input): Array of length nca containing the upper bound on the variables. If there is no lower bound on the i‑th variable, then xub[i] should be set to −1.0e30.

Return Value¶

A vector of length nca containing the approximate solution. If no solution was computed, then None is returned.

Optional Arguments¶

residual, float residual (Output)

An array containing the residuals b − Ax of the least-squares equations at the approximate solution.

t_print,

Debug output flag. Choose this option if more detailed output is desired.

maxIter (Input)

Set the maximum number of add/drop iterations.

Default: maxIter = 5*max(nra, nca)

relFcnTol, float (Input)

Relative rank determination tolerance to be used.

Default: relFcnTol = sqrt(machine(4))

absFcnTol, float (Input)

Absolute rank determination tolerance to be used.

Default: absFcnTol = sqrt(machine(4))

Description¶

The function linLsqLinConstraints solves linear least-squares problems with linear constraints. These are systems of least-squares equations of the form

\[Ax ≅ b\]

subject to

\[b_l ≤Cx ≤b_u\]

\[x_l ≤x ≤ x_u\]

Here A is the coefficient matrix of the least-squares equations, b is the right-hand side, and C is the coefficient matrix of the constraints. The vectors \(b_l\), \(b_u\), \(x_l\) and \(x_u\) are the lower and upper bounds on the constraints and the variables, respectively. The system is solved by defining dependent variables y ≡ Cx and then solving the least-squares system with the lower and upper bounds on x and y. The equation \(Cx − y = 0\) is a set of equality constraints. These constraints are realized by heavy weighting, i.e., a penalty method, Hanson (1986, pp. 826-834).

Examples¶

Example 1¶

In this example, the following problem is solved in the least-squares sense:

\[3x_1 + 2x_2 + x_3 = 3.3\]

\[4x_1 +2x_2 + x_3 = 2.2\]

\[2x_1 + 2x_2 + x_3 = 1.3\]

\[x_1 + x_2 + x_3 = 1.0\]

Subject to

\[x_1 = x_2 + x_3 ≤ 1\]

\[0 ≤x_1 ≤ 0.5\]

\[0 ≤ x_2 ≤ 0.5\]

\[0 ≤ x_3 ≤ 0.5\]

from numpy import *
from pyimsl.math.linLsqLinConstraints import linLsqLinConstraints
from pyimsl.math.vectorNorm import vectorNorm
from pyimsl.math.writeMatrix import writeMatrix

a = array([[3.0, 2.0, 1.0],
           [4.0, 2.0, 1.0],
           [2.0, 2.0, 1.0],
           [1.0, 1.0, 1.0]])
b = array([3.3, 2.3, 1.3, 1.0])
c = array([[1.0, 1.0, 1.0]])
xlb = array([0.0, 0.0, 0.0])
xub = array([0.5, 0.5, 0.5])
con_type = array([1])
bc = array([1.0])
residual = []
x = linLsqLinConstraints(a, b, c,
                         bc, bc, con_type, xlb, xub)
writeMatrix("Solution", x)

Output¶

 
              Solution
          1            2            3
        0.5          0.3          0.2

Example 2¶

The same problem solved in the first example is solved again. This time residuals of the least-squares equations at the approximate solution are returned, and the norm of the residual vector is printed. Both the solution and residuals are returned in user-supplied space.

from __future__ import print_function
from numpy import *
from pyimsl.math.linLsqLinConstraints import linLsqLinConstraints
from pyimsl.math.vectorNorm import vectorNorm
from pyimsl.math.writeMatrix import writeMatrix

a = array([[3.0, 2.0, 1.0],
           [4.0, 2.0, 1.0],
           [2.0, 2.0, 1.0],
           [1.0, 1.0, 1.0]])
b = array([3.3, 2.3, 1.3, 1.0])
c = array([[1.0, 1.0, 1.0]])
xlb = array([0.0, 0.0, 0.0])
xub = array([0.5, 0.5, 0.5])
con_type = array([1])
bc = array([1.0])
residual = []
x = linLsqLinConstraints(a, b, c,
                         bc, bc, con_type, xlb, xub,
                         residual=residual)
writeMatrix("Solution", x)
writeMatrix("Residual", residual)
print("\nNorm of residual = %f" % (vectorNorm(residual)))

Output¶

Norm of residual = 1.224745
 
              Solution
          1            2            3
        0.5          0.3          0.2
 
                     Residual
          1            2            3            4
       -1.0          0.5          0.5          0.0

Fatal Errors¶

`IMSL_BAD_COLUMN_ORDER`	The input order of columns must be between 1 and “`nvar`” while input order = # and “`nvar`” = # are given.
`IMSL_BAD_POLARITY_FLAGS`	The bound polarity flags must be positive while component # flag “ibb[#]”.
`IMSL_TOO_MANY_ITN`	Maximum numbers of iterations exceeded.