Solves a linear least-squares problem with linear constraints.
#include <imsl.h>
float *imsl_f_lin_lsq_lin_constraints (int nra, int nca, int ncon, float a[], float b[], float c[], float bl[], float bu[], int con_type[], float xlb[], float xub[], ..., 0)
The type double function is imsl_d_lin_lsq_lin_constraints.
int nra
(Input)
Number of least-squares equations.
int nca
(Input)
Number of variables.
int ncon
(Input)
Number of constraints.
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
con_type[] (Input)
Array of length ncon indicating the
type of constraints exclusive of simple bounds, where con_type[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.
A pointer to the to a vector of length nca containing the approximate solution. To release this space, use free. If no solution was computed, then NULL is returned.
#include <imsl.h>
float
*imsl_f_lin_lsq_lin_constraints (int nra, int nca, int
ncon, float a[], float b[], float c[], float bl[],
float bu[], int con_type[], float xlb[], float
xub[],
IMSL_RETURN_USER, float x[],
IMSL_RESIDUAL, float
**residual,
IMSL_RESIDUAL_USER, float
residual_user[],
IMSL_PRINT,
IMSL_MAX_ITER, int
max_iter,
IMSL_REL_FCN_TOL, float rel_tol,
IMSL_ABS_FCN_TOL,
float abs_tol,
0)
IMSL_RETURN_USER, float x[]
(Output)
Store the solution in the user supplied vector x of length nca.
IMSL_RESIDUAL, float
**residual (Output)
The address of a pointer to an array
containing the residuals b − Ax of the
least-squares equations at the approximate solution.
IMSL_RESIDUAL_USER, float
residual_user[] (Output)
Store the residuals in the
user-supplied vector of length nra.
IMSL_PRINT,
Debug
output flag. Choose this option if more detailed output is desired.
IMSL_MAX_ITER, int max_iter
(Input)
Set the maximum number of add/drop iterations.
Default: max_iter = 5*max(nra, nca)
IMSL_REL_FCN_TOL, float rel_tol
(Input)
Relative rank determination tolerance to be used.
Default: rel_tol = sqrt(imsl_f_machine(4))
IMSL_ABS_FCN_TOL, float abs_tol
(Input)
Absolute rank determination tolerance to be used.
Default: abs_tol = sqrt(imsl_f_machine(4))
The function imsl_f_lin_lsq_lin_constraints solves linear least-squares problems with linear constraints. These are systems of least-squares equations of the form
Ax ≅ b
subject to
bl £ Cx £ bu
xl £ x £ xu
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 bl, bu, xl and xu 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).
In this example, the following problem is solved in the least-squares sense:
3x1 + 2x2 + x3 = 3.3
4x1 +2x2 + x3 = 2.2
2x1 + 2x2 + x3 = 1.3
x1 + x2 + x3 = 1.0
Subject to
x1 = x2 + x3 £ 1
0 £ x1 £ 0.5
0 £ x2 £ 0.5
0 £ x3 £ 0.5
#include <imsl.h>
main()
{
int nra = 4;
int nca = 3;
int ncon = 1;
float *x;
float a[] = {3.0, 2.0, 1.0,
4.0, 2.0, 1.0,
2.0, 2.0, 1.0,
1.0, 1.0, 1.0};
float b[] = {3.3, 2.3, 1.3, 1.0};
float c[] = {1.0, 1.0, 1.0};
float xlb[] = {0.0, 0.0, 0.0};
float xub[] = {0.5, 0.5, 0.5};
int con_type[] = {1};
float bc[] = {1.0};
x =
imsl_f_lin_lsq_lin_constraints (nra, nca, ncon, a, b, c,
bc, bc, con_type, xlb, xub, 0);
imsl_f_write_matrix ("Solution", 1, nca, x, 0);
}
Solution
1 2 3
0.5 0.3 0.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.
#include <imsl.h>
main()
{
int nra = 4;
int nca = 3;
int ncon = 1;
float x[3];
float residual[4];
float a[] = {3.0, 2.0, 1.0,
4.0, 2.0, 1.0,
2.0, 2.0, 1.0,
1.0, 1.0, 1.0};
float b[] = {3.3, 2.3, 1.3, 1.0};
float c[] = {1.0, 1.0, 1.0};
float xlb[] = {0.0, 0.0, 0.0};
float xub[] = {0.5, 0.5, 0.5};
int con_type[] = {1};
float bc[] = {1.0};
imsl_f_lin_lsq_lin_constraints (nra, nca, ncon, a, b, c,
bc, bc, con_type, xlb, xub,
IMSL_RETURN_USER, x,
IMSL_RESIDUAL_USER, residual,
0);
imsl_f_write_matrix ("Solution", 1, nca, x, 0);
imsl_f_write_matrix ("Residual", 1, nra, residual, 0);
printf ("\n\nNorm of residual = %f\n",
imsl_f_vector_norm (nra, residual, 0));
}
Solution
1 2 3
0.5 0.3 0.2
Residual
1 2 3 4
-1.0 0.5 0.5 -0.0
Norm of residual = 1.224745
|
Visual Numerics, Inc. PHONE: 713.784.3131 FAX:713.781.9260 |