MATLAB Function Reference  lsqnonneg

Linear least squares with nonnegativity constraints

Syntax

• ```x = lsqnonneg(C,d)
x = lsqnonneg(C,d,x0)
x = lsqnonneg(C,d,x0,options)
[x,resnorm] = lsqnonneg(...)
[x,resnorm,residual] = lsqnonneg(...)
[x,resnorm,residual,exitflag] = lsqnonneg(...)
[x,resnorm,residual,exitflag,output] = lsqnonneg(...)
[x,resnorm,residual,exitflag,output,lambda] = lsqnonneg(...)
```

Description

```x = lsqnonneg(C,d) ``` returns the vector `x` that minimizes `norm(C*x-d)` subject to `x >= 0`. `C` and `d` must be real.

```x = lsqnonneg(C,d,x0) ``` uses `x0` as the starting point if all `x0 >= 0`; otherwise, the default is used. The default start point is the origin (the default is used when `x0==[ ]` or when only two input arguments are provided).

```x = lsqnonneg(C,d,x0,options) ``` minimizes with the optimization parameters specified in the structure `options`. You can define these parameters using the `optimset` function. `lsqnonneg` uses these `options` structure fields:

 `Display` Level of display. `'off'` displays no output; `'final'` displays just the final output; `'notify'` (default) dislays output only if the function does not converge. `TolX` Termination tolerance on `x.`

```[x,resnorm] = lsqnonneg(...) ``` returns the value of the squared 2-norm of the residual: `norm(C*x-d)^2`.

```[x,resnorm,residual] = lsqnonneg(...) ``` returns the residual, `C*x-d`.

```[x,resnorm,residual,exitflag] = lsqnonneg(...) ``` returns a value `exitflag` that describes the exit condition of lsqnonneg:

 >0 Indicates that the function converged to a solution `x.` 0 Indicates that the iteration count was exceeded. Increasing the tolerance (`TolX` parameter in `options`) may lead to a solution.

```[x,resnorm,residual,exitflag,output] = lsqnonneg(...) ``` returns a structure `output` that contains information about the operation:

 `output.algorithm` The algorithm used `output.iterations` The number of iterations taken

```[x,resnorm,residual,exitflag,output,lambda] = lsqnonneg(...) ``` returns the dual vector (Lagrange multipliers) `lambda`, where `lambda(i)<=0` when `x(i)` is (approximately) `0`, and `lambda(i)` is (approximately) `0` when `x(i)>0`.

Examples

Compare the unconstrained least squares solution to the `lsqnonneg` solution for a 4-by-2 problem:

• ```C = [
`    `0.0372`    `0.2869
`    `0.6861`    `0.7071
`    `0.6233`    `0.6245
`    `0.6344`    `0.6170];
d = [
`    `0.8587
`    `0.1781
`    `0.0747
`    `0.8405];
[C\d` `lsqnonneg(C,d)]` `=
-2.5627`         `0
`     `3.1108  ` `0.6929
[norm`(C`*`(C\`d)-d)` `norm(`C`*`l`sqnonneg(C,d)-d)]` `=
`     `0.6674` `0.9118
```

The solution from `lsqnonneg` does not fit as well (has a larger residual), as the least squares solution. However, the nonnegative least squares solution has no negative components.

Algorithm

`lsqnonneg` uses the algorithm described in . The algorithm starts with a set of possible basis vectors and computes the associated dual vector `lambda`. It then selects the basis vector corresponding to the maximum value in `lambda` in order to swap out of the basis in exchange for another possible candidate. This continues until `lambda <= 0`.

The arithmetic operator `\`, `optimset` lscov lsqr 