lsqlin
Solve constrained linear least-squares problems
Syntax
Description
Linear least-squares solver with bounds or linear constraints.
Solves least-squares curve fitting problems of the form
Note
lsqlin applies only to the solver-based approach. Use solve for the
problem-based approach. For a discussion of the two optimization approaches, see First Choose Problem-Based or Solver-Based Approach.
x = lsqlin(C,d,A,b,Aeq,beq,lb,ub,x0,options)x0 and the optimization options
specified in options. Use optimoptions to set these options. If you do not want to include an initial
point, set the x0 argument to []; however, a
nonempty x0 is required for the 'active-set'
algorithm.
x = lsqlin(problem)problem, a structure described in problem. Create the problem structure using dot notation
or the struct function. Or create a
problem structure from an OptimizationProblem
object by using prob2struct.
[, for any input arguments described above,
returns:x,resnorm,residual,exitflag,output,lambda]
= lsqlin(___)
The squared 2-norm of the residual
resnorm =The residual
residual = C*x - dA value
exitflagdescribing the exit conditionA structure
outputcontaining information about the optimization processA structure
lambdacontaining the Lagrange multipliersThe factor ½ in the definition of the problem affects the values in the
lambdastructure.
[
starts wsout,resnorm,residual,exitflag,output,lambda]
= lsqlin(C,d,A,b,Aeq,beq,lb,ub,ws)lsqlin from the data in the warm start object
ws, using the options in ws. The returned argument
wsout contains the solution point in wsout.X. By
using wsout as the initial warm start object in a subsequent solver
call, lsqlin can work faster.
Examples
Find the x that minimizes the norm of C*x - d for an overdetermined problem with linear inequality constraints.
Specify the problem and constraints.
C = [0.9501 0.7620 0.6153 0.4057
0.2311 0.4564 0.7919 0.9354
0.6068 0.0185 0.9218 0.9169
0.4859 0.8214 0.7382 0.4102
0.8912 0.4447 0.1762 0.8936];
d = [0.0578
0.3528
0.8131
0.0098
0.1388];
A = [0.2027 0.2721 0.7467 0.4659
0.1987 0.1988 0.4450 0.4186
0.6037 0.0152 0.9318 0.8462];
b = [0.5251
0.2026
0.6721];Call lsqlin to solve the problem.
x = lsqlin(C,d,A,b)
Minimum found that satisfies the constraints. Optimization completed because the objective function is non-decreasing in feasible directions, to within the value of the optimality tolerance, and constraints are satisfied to within the value of the constraint tolerance. <stopping criteria details>
x = 4×1
0.1299
-0.5757
0.4251
0.2438
Find the x that minimizes the norm of C*x - d for an overdetermined problem with linear equality and inequality constraints and bounds.
Specify the problem and constraints.
C = [0.9501 0.7620 0.6153 0.4057
0.2311 0.4564 0.7919 0.9354
0.6068 0.0185 0.9218 0.9169
0.4859 0.8214 0.7382 0.4102
0.8912 0.4447 0.1762 0.8936];
d = [0.0578
0.3528
0.8131
0.0098
0.1388];
A =[0.2027 0.2721 0.7467 0.4659
0.1987 0.1988 0.4450 0.4186
0.6037 0.0152 0.9318 0.8462];
b =[0.5251
0.2026
0.6721];
Aeq = [3 5 7 9];
beq = 4;
lb = -0.1*ones(4,1);
ub = 2*ones(4,1);Call lsqlin to solve the problem.
x = lsqlin(C,d,A,b,Aeq,beq,lb,ub)
Minimum found that satisfies the constraints. Optimization completed because the objective function is non-decreasing in feasible directions, to within the value of the optimality tolerance, and constraints are satisfied to within the value of the constraint tolerance. <stopping criteria details>
x = 4×1
-0.1000
-0.1000
0.1599
0.4090
This example shows how to use nondefault options for linear least squares.
Set options to use the 'interior-point' algorithm and to give iterative display.
options = optimoptions('lsqlin','Algorithm','interior-point','Display','iter');
Set up a linear least-squares problem.
C = [0.9501 0.7620 0.6153 0.4057
0.2311 0.4564 0.7919 0.9354
0.6068 0.0185 0.9218 0.9169
0.4859 0.8214 0.7382 0.4102
0.8912 0.4447 0.1762 0.8936];
d = [0.0578
0.3528
0.8131
0.0098
0.1388];
A = [0.2027 0.2721 0.7467 0.4659
0.1987 0.1988 0.4450 0.4186
0.6037 0.0152 0.9318 0.8462];
b = [0.5251
0.2026
0.6721];Run the problem.
x = lsqlin(C,d,A,b,[],[],[],[],[],options)
Iter Resnorm Primal Infeas Dual Infeas Complementarity
0 6.545534e-01 1.600492e+00 6.150431e-01 1.000000e+00
1 6.545534e-01 8.002458e-04 3.075216e-04 2.430833e-01
2 1.757343e-01 4.001229e-07 1.537608e-07 5.945636e-02
3 5.619277e-02 2.000615e-10 1.196168e-08 1.370933e-02
4 2.587604e-02 9.997558e-14 1.006395e-08 2.548273e-03
5 1.868939e-02 1.665335e-16 6.098591e-11 4.295807e-04
6 1.764630e-02 2.775558e-17 1.606174e-12 3.102849e-05
7 1.758561e-02 1.387779e-16 3.913536e-15 1.138721e-07
8 1.758538e-02 2.498002e-16 1.804112e-16 5.693297e-11
Minimum found that satisfies the constraints.
Optimization completed because the objective function is non-decreasing in
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the value of the constraint tolerance.
<stopping criteria details>
x = 4×1
0.1299
-0.5757
0.4251
0.2438
Obtain and interpret all lsqlin outputs.
Define a problem with linear inequality constraints and bounds. The problem is overdetermined because there are four columns in the C matrix but five rows. This means the problem has four unknowns and five conditions, even before including the linear constraints and bounds.
C = [0.9501 0.7620 0.6153 0.4057
0.2311 0.4564 0.7919 0.9354
0.6068 0.0185 0.9218 0.9169
0.4859 0.8214 0.7382 0.4102
0.8912 0.4447 0.1762 0.8936];
d = [0.0578
0.3528
0.8131
0.0098
0.1388];
A = [0.2027 0.2721 0.7467 0.4659
0.1987 0.1988 0.4450 0.4186
0.6037 0.0152 0.9318 0.8462];
b = [0.5251
0.2026
0.6721];
lb = -0.1*ones(4,1);
ub = 2*ones(4,1);Set options to use the 'interior-point' algorithm.
options = optimoptions('lsqlin','Algorithm','interior-point');
The 'interior-point' algorithm does not use an initial point, so set x0 to [].
x0 = [];
Call lsqlin with all outputs.
[x,resnorm,residual,exitflag,output,lambda] = ...
lsqlin(C,d,A,b,[],[],lb,ub,x0,options)Minimum found that satisfies the constraints. Optimization completed because the objective function is non-decreasing in feasible directions, to within the value of the optimality tolerance, and constraints are satisfied to within the value of the constraint tolerance. <stopping criteria details>
x = 4×1
-0.1000
-0.1000
0.2152
0.3502
resnorm = 0.1672
residual = 5×1
0.0455
0.0764
-0.3562
0.1620
0.0784
exitflag = 1
output = struct with fields:
message: 'Minimum found that satisfies the constraints.↵↵Optimization completed because the objective function is non-decreasing in ↵feasible directions, to within the value of the optimality tolerance,↵and constraints are satisfied to within the value of the constraint tolerance.↵↵<stopping criteria details>↵↵Optimization completed: The relative dual feasibility, 8.007147e-17,↵is less than options.OptimalityTolerance = 1.000000e-08, the complementarity measure,↵1.693156e-10, is less than options.OptimalityTolerance, and the relative maximum constraint↵violation, 0.000000e+00, is less than options.ConstraintTolerance = 1.000000e-08.'
algorithm: 'interior-point'
firstorderopt: 1.6932e-10
constrviolation: 0
iterations: 6
linearsolver: 'dense'
cgiterations: []
lambda = struct with fields:
ineqlin: [3×1 double]
eqlin: [0×1 double]
lower: [4×1 double]
upper: [4×1 double]
Examine the nonzero Lagrange multiplier fields in more detail. First examine the Lagrange multipliers for the linear inequality constraint.
lambda.ineqlin
ans = 3×1
0.0000
0.2392
0.0000
Lagrange multipliers are nonzero exactly when the solution is on the corresponding constraint boundary. In other words, Lagrange multipliers are nonzero when the corresponding constraint is active. lambda.ineqlin(2) is nonzero. This means that the second element in A*x should equal the second element in b, because the constraint is active.
[A(2,:)*x,b(2)]
ans = 1×2
0.2026 0.2026
Now examine the Lagrange multipliers for the lower and upper bound constraints.
lambda.lower
ans = 4×1
0.0409
0.2784
0.0000
0.0000
lambda.upper
ans = 4×1
0
0
0
0
The first two elements of lambda.lower are nonzero. You see that x(1) and x(2) are at their lower bounds, -0.1. All elements of lambda.upper are essentially zero, and you see that all components of x are less than their upper bound, 2.
Create a warm start object so you can solve a modified problem quickly. Set options to turn off iterative display to support warm start.
rng default % For reproducibility options = optimoptions('lsqlin','Algorithm','active-set','Display','off'); n = 15; x0 = 5*rand(n,1); ws = optimwarmstart(x0,options);
Create and solve the first problem. Find the solution time.
r = 1:n-1; % Index for making vectors v(n) = (-1)^(n+1)/n; % Allocating the vector v v(r) =( -1).^(r+1)./r; C = gallery('circul',v); C = [C;C]; r = 1:2*n; d(r) = n-r; lb = -5*ones(1,n); ub = 5*ones(1,n); tic [ws,fval,~,exitflag,output] = lsqlin(C,d,[],[],[],[],lb,ub,ws) toc
Elapsed time is 0.005117 seconds.
Add a linear constraint and solve again.
A = ones(1,n); b = -10; tic [ws,fval,~,exitflag,output] = lsqlin(C,d,A,b,[],[],lb,ub,ws) toc
Elapsed time is 0.001491 seconds.
Input Arguments
Multiplier matrix, specified as a matrix of doubles. C represents
the multiplier of the solution x in the expression C*x -
d. C is M-by-N,
where M is the number of equations, and N is the
number of elements of x.
Example: C = [1,4;2,5;7,8]
Data Types: single | double
Constant vector, specified as a vector of doubles. d represents
the additive constant term in the expression C*x - d.
d is M-by-1, where
M is the number of equations.
Example: d = [5;0;-12]
Data Types: single | double
Linear inequality constraints, specified as a real matrix. A is an
M-by-N
matrix, where M is the number of
inequalities, and N is the number
of variables (number of elements in
x0). For large problems with
algorithms that support sparse data, pass
A as a sparse matrix. See Sparsity in Optimization Algorithms.
A encodes the M linear
inequalities
A*x <= b,
where x is the column vector of N variables x(:),
and b is a column vector with M elements.
For example, consider these inequalities:
x1 + 2x2 ≤
10
3x1 +
4x2 ≤ 20
5x1 +
6x2 ≤ 30,
Specify the inequalities by entering the following constraints.
A = [1,2;3,4;5,6]; b = [10;20;30];
Example: To specify that the x components sum to 1 or less, use A =
ones(1,N) and b = 1.
Data Types: single | double
Linear inequality constraints, specified as a real vector. b is an
M-element vector related to the A matrix. If
you pass b as a row vector, solvers internally convert
b to the column vector b(:).
b encodes the M linear
inequalities
A*x <= b,
where x is the column vector of N variables x(:),
and A is a matrix of size M-by-N.
For example, consider these inequalities:
x1
+ 2x2 ≤
10
3x1
+ 4x2 ≤
20
5x1
+ 6x2 ≤
30.
Specify the inequalities by entering the following constraints.
A = [1,2;3,4;5,6]; b = [10;20;30];
Example: To specify that the x components sum to 1 or less, use A =
ones(1,N) and b = 1.
Data Types: single | double
Linear equality constraints, specified as a real matrix. Aeq is an
Me-by-N
matrix, where Me is the number of
equalities, and N is the number
of variables (number of elements in
x0). For large problems with
algorithms that support sparse data, pass
A as a sparse matrix. See Sparsity in Optimization Algorithms.
Aeq encodes the Me linear
equalities
Aeq*x = beq,
where x is the column vector of N variables x(:),
and beq is a column vector with Me elements.
For example, consider these inequalities:
x1 + 2x2 +
3x3 = 10
2x1 +
4x2 + x3 =
20,
Specify the inequalities by entering the following constraints.
Aeq = [1,2,3;2,4,1]; beq = [10;20];
Example: To specify that the x components sum to 1, use Aeq = ones(1,N) and
beq = 1.
Data Types: single | double
Linear equality constraints, specified as a real vector. beq is an
Me-element vector related to the Aeq matrix.
If you pass beq as a row vector, solvers internally convert
beq to the column vector beq(:).
beq encodes the Me linear
equalities
Aeq*x = beq,
where x is the column vector of N variables
x(:), and Aeq is a matrix of size
Me-by-N.
For example, consider these equalities:
x1
+ 2x2 +
3x3 =
10
2x1
+ 4x2 +
x3 =
20.
Specify the equalities by entering the following constraints.
Aeq = [1,2,3;2,4,1]; beq = [10;20];
Example: To specify that the x components sum to 1, use Aeq = ones(1,N) and
beq = 1.
Data Types: single | double
Lower bounds, specified as a vector or array of doubles. lb
represents the lower bounds elementwise in
lb ≤ x ≤ ub.
Internally, lsqlin converts an array lb to
the vector lb(:).
Example: lb = [0;-Inf;4] means x(1) ≥ 0,
x(3) ≥ 4.
Data Types: single | double
Upper bounds, specified as a vector or array of doubles. ub
represents the upper bounds elementwise in
lb ≤ x ≤ ub.
Internally, lsqlin converts an array ub to
the vector ub(:).
Example: ub = [Inf;4;10] means x(2) ≤ 4,
x(3) ≤ 10.
Data Types: single | double
Initial point for the solution process, specified as a real vector or array.
The
'interior-point'algorithm does not usex0.x0is an optional argument for the'trust-region-reflective'algorithm. By default, this algorithm setsx0to an all-zero vector. If any of these components violate the bound constraints,lsqlinresets the entire defaultx0to a vector that satisfies the bounds. If any components of a nondefaultx0violates the bounds,lsqlinsets those components to satisfy the bounds.A nonempty
x0is a required argument for the'active-set'algorithm. If any components ofx0violates the bounds,lsqlinsets those components to satisfy the bounds.
Example: x0 = [4;-3]
Data Types: single | double
Options for lsqlin, specified as the output of the optimoptions function or as a structure such as created by
optimset.
Some options are absent from the
optimoptions display. These options appear in italics in the following
table. For details, see View Optimization Options.
All Algorithms
| Choose the algorithm:
The The
When the problem has no constraints,
If you have a large number of linear constraints and
not a large number of variables, try the For more information on choosing the algorithm, see Choosing the Algorithm. |
| Diagnostics | Display diagnostic information about the function to be minimized or
solved. The choices are |
Display | Level of display returned to the command line.
The
|
MaxIterations | Maximum number of iterations allowed, a nonnegative integer. The
default value is For |
trust-region-reflective Algorithm Options
FunctionTolerance | Termination tolerance on the function value, a
nonnegative scalar. The default is For |
JacobianMultiplyFcn | Jacobian multiply
function, specified as a function handle. For large-scale structured problems,
this function should compute the Jacobian matrix product
W = jmfun(Jinfo,Y,flag) where
In each case, See Jacobian Multiply Function with Linear Least Squares for an example. For |
| MaxPCGIter | Maximum number of PCG (preconditioned conjugate
gradient) iterations, a positive scalar. The default is
|
OptimalityTolerance | Termination tolerance on the first-order
optimality, a nonnegative scalar. The default is For |
| PrecondBandWidth | Upper bandwidth of preconditioner for PCG
(preconditioned conjugate gradient). By default, diagonal preconditioning is
used (upper bandwidth of 0). For some problems, increasing the bandwidth
reduces the number of PCG iterations. Setting
|
SubproblemAlgorithm | Determines how the iteration step is
calculated. The default, |
| TolPCG | Termination tolerance on the PCG
(preconditioned conjugate gradient) iteration, a positive scalar. The default
is |
TypicalX | Typical |
interior-point Algorithm Options
ConstraintTolerance | Tolerance on the constraint violation, a nonnegative
scalar. The default is For
|
LinearSolver | Type of internal linear solver in algorithm:
|
OptimalityTolerance | Termination tolerance on the first-order
optimality, a nonnegative scalar. The default is For |
StepTolerance | Termination tolerance on For
|
'active-set' Algorithm Options
ConstraintTolerance | Tolerance on the constraint violation, a positive scalar. The default
value is For |
ObjectiveLimit | A tolerance (stopping criterion) that is a
scalar. If the objective function value goes below
|
OptimalityTolerance | Termination tolerance on the first-order
optimality, a positive scalar. The default value is For |
StepTolerance | Termination tolerance on For |
UseCodegenSolver | Indication to use the version of the software that runs on
target hardware, specified as |
Single-Precision Code Generation
Algorithm | Must be |
ConstraintTolerance | Tolerance on the constraint violation, a positive scalar. The default value is For |
MaxIterations | Maximum number of iterations allowed, a nonnegative integer. The default value is |
ObjectiveLimit | A tolerance (stopping criterion) that is a scalar. If the objective function value goes below |
OptimalityTolerance | Termination tolerance on the first-order optimality, a positive scalar. The default value is For |
StepTolerance | Termination tolerance on For |
UseCodegenSolver | Indication to use the version of the software that runs on
target hardware, specified as |
Optimization problem, specified as a structure with the following fields.
| Matrix multiplier in the term C*x -
d |
| Additive constant in the term C*x -
d |
| Matrix for linear inequality constraints |
| Vector for linear inequality constraints |
| Matrix for linear equality constraints |
| Vector for linear equality constraints |
lb | Vector of lower bounds |
ub | Vector of upper bounds |
| Initial point for x |
| 'lsqlin' |
| Options created with optimoptions |
Note
You cannot use warm start with the problem argument.
Data Types: struct
Warm start object, specified as an object created using optimwarmstart. The warm start object contains the start point and
options, and optional data for memory size in code generation. See Warm Start Best Practices.
Example: ws = optimwarmstart(x0,options)
Output Arguments
Solution, returned as a vector that minimizes the norm of C*x-d
subject to all bounds and linear constraints.
Solution warm start object, returned as a LsqlinWarmStart object.
The solution point is wsout.X.
You can use wsout as the input warm start object in a subsequent
lsqlin call.
Objective value, returned as the scalar value
norm(C*x-d)^2.
Solution residuals, returned as the vector C*x-d.
Algorithm stopping condition, returned as an integer identifying the reason the
algorithm stopped. The following lists the values of exitflag and the
corresponding reasons lsqlin stopped.
| Change in the residual was smaller than the specified
tolerance |
| Step size smaller than
|
| Function converged to a solution
|
| Number of iterations exceeded
|
| The problem is infeasible. Or, for the
|
-3 | The problem is unbounded. |
| Ill-conditioning prevents further optimization. |
| Unable to compute a step direction. |
The exit message for the interior-point algorithm can give more
details on the reason lsqlin stopped, such as exceeding a
tolerance. See Exit Flags and Exit Messages.
Solution process summary, returned as a structure containing information about the optimization process.
| Number of iterations the solver took. |
| One of these algorithms:
For an unconstrained problem, |
| Constraint violation that is positive for
violated constraints (not returned for the
|
| Exit message. |
| First-order optimality at the solution. See First-Order Optimality Measure. |
linearsolver | Type of internal linear solver,
|
| Number of conjugate gradient iterations the
solver performed. Nonempty only for the
|
See Output Structures.
Lagrange multipliers, returned as a structure with the following fields.
| Lower bounds |
| Upper bounds |
| Linear inequalities |
| Linear equalities |
Tips
For problems with no constraints, consider using
mldivide(matrix left division) orlsqminnorm. When you have no constraints,lsqlinreturnsx = C\d.Because the problem being solved is always convex,
lsqlinfinds a global, although not necessarily unique, solution.If your problem has many linear constraints and few variables, try using the
'active-set'algorithm. See Quadratic Programming with Many Linear Constraints.Better numerical results are likely if you specify equalities explicitly, using
Aeqandbeq, instead of implicitly, usinglbandub.The
trust-region-reflectivealgorithm does not allow equal upper and lower bounds. Use another algorithm for this case.If the specified input bounds for a problem are inconsistent, the output
xisx0and the outputsresnormandresidualare[].You can solve some large structured problems, including those where the
Cmatrix is too large to fit in memory, using thetrust-region-reflectivealgorithm with a Jacobian multiply function. For information, see trust-region-reflective Algorithm Options.
Algorithms
This method is a subspace trust-region method based on the interior-reflective Newton method described in [1]. Each iteration involves the approximate solution of a large linear system using the method of preconditioned conjugate gradients (PCG). See Trust-Region-Reflective Least Squares, and in particular Large Scale Linear Least Squares.
The 'interior-point' algorithm is based on the
quadprog
'interior-point-convex' algorithm. See Linear Least Squares: Interior-Point or Active-Set.
The 'active-set' algorithm is based on the
quadprog
'active-set' algorithm. For more information, see Linear Least Squares: Interior-Point or Active-Set and active-set quadprog Algorithm.
For unconstrained problems, lsqlin performs a decomposition of the
C coefficient matrix using decomposition.
When lsqlin detects that the C matrix is
ill-conditioned, lsqlin uses QR decomposition to solve the
problem.
References
[1] Coleman, T. F. and Y. Li. “A Reflective Newton Method for Minimizing a Quadratic Function Subject to Bounds on Some of the Variables,” SIAM Journal on Optimization, Vol. 6, Number 4, pp. 1040–1058, 1996.
[2] Gill, P. E., W. Murray, and M. H. Wright. Practical Optimization, Academic Press, London, UK, 1981.
A warm start object maintains a list of active constraints from the previous solved problem. The solver carries over as much active constraint information as possible to solve the current problem. If the previous problem is too different from the current one, no active set information is reused. In this case, the solver effectively executes a cold start in order to rebuild the list of active constraints.
Alternative Functionality
App
The Optimize Live Editor task provides a visual interface for lsqlin.
Extended Capabilities
Usage notes and limitations:
lsqlinsupports code generation using either thecodegen(MATLAB Coder) function or the MATLAB® Coder™ app. You must have a MATLAB Coder license to generate code.The target hardware must support standard double-precision floating-point computations or standard single-precision floating-point computations.
Code generation targets do not use the same math kernel libraries as MATLAB solvers. Therefore, code generation solutions can vary from solver solutions, especially for poorly conditioned problems.
To test your code in MATLAB before generating code, set the
UseCodegenSolveroption totrue. That way, the solver uses the same code that code generation creates.When solving unconstrained and underdetermined problems in MATLAB,
lsqlincallsmldivide, which returns a basic solution. In code generation, the returned solution has minimum norm, which usually differs.lsqlindoes not support theproblemargument for code generation.[x,fval] = lsqlin(problem) % Not supportedAll
lsqlininput matrices such asA,Aeq,lb, andubmust be full, not sparse. You can convert sparse matrices to full by using thefullfunction.The
lbandubarguments must have the same number of entries as the number of columns inCor must be empty[].If your target hardware does not support infinite bounds, use
optim.coder.infbound.For advanced code optimization involving embedded processors, you also need an Embedded Coder® license.
You must include options for
lsqlinand specify them usingoptimoptions. The options must include theAlgorithmoption, set to'active-set'.options = optimoptions("lsqlin",Algorithm="active-set"); [x,fval,exitflag] = lsqlin(C,d,A,b,Aeq,beq,lb,ub,x0,options);
Code generation supports these options:
Algorithm— Must be'active-set'ConstraintToleranceMaxIterationsObjectiveLimitOptimalityToleranceStepToleranceUseCodegenSolver
Generated code has limited error checking for options. The recommended way to update an option is to use
optimoptions, not dot notation.opts = optimoptions('lsqlin','Algorithm','active-set'); opts = optimoptions(opts,'MaxIterations',1e4); % Recommended opts.MaxIterations = 1e4; % Not recommended
Do not load options from a file. Doing so can cause code generation to fail. Instead, create options in your code.
If you specify an option that is not supported, the option is typically ignored during code generation. For reliable results, specify only supported options.
Version History
Introduced before R2006aSet the new UseCodegenSolver option to true to have
lsqlin use the same version of the software that code
generation creates. This option allows you to check the behavior of the solver before you
generate code or deploy the code to hardware. For solvers that support single-precision code
generation, the generated code can also support single-precision hardware. You can include
the option when you generate code; the option has no effect in code generation, but leaving
the option in saves you the step of removing it. Even though the generated code is identical
to the MATLAB code, results can differ slightly because linked math libraries can
differ.
You can generate code using lsqlin for single-precision floating
point hardware. For instructions, see Single-Precision Code Generation.
The solver now takes extra steps when solving an ill-conditioned unconstrained problem
with a square input matrix C (the number of rows equals the number of
columns). The results can have improved accuracy and the likelihood of obtaining an
Inf or NaN result is decreased.
For unconstrained problems, the output.algorithm field is now
'direct' instead of the previous 'mldivide'.
MATLAB Command
You clicked a link that corresponds to this MATLAB command:
Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.
Sélectionner un site web
Choisissez un site web pour accéder au contenu traduit dans votre langue (lorsqu'il est disponible) et voir les événements et les offres locales. D’après votre position, nous vous recommandons de sélectionner la région suivante : .
Vous pouvez également sélectionner un site web dans la liste suivante :
Comment optimiser les performances du site
Pour optimiser les performances du site, sélectionnez la région Chine (en chinois ou en anglais). Les sites de MathWorks pour les autres pays ne sont pas optimisés pour les visites provenant de votre région.
Amériques
- América Latina (Español)
- Canada (English)
- United States (English)
Europe
- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)
- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)