Description Usage Arguments Details Value Author(s) References See Also Examples

These functions are particularly useful for solving least squares or quadratic programming problems when some or all of the solution values are subject to nonnegativity constraint. One may further restrict the NN-restricted coefficients to have a fixed positive sum.

1 2 3 |

`a` |
Design matrix. |

`b` |
Response vector. |

`k` |
Integer, meaning that the first |

`sum` |
= NULL, if NN-restricted coefficients are not further restricted to have a fixed sum; = a positive value, if NN-restricted coefficients are further restricted to have a fixed positive sum. |

`q` |
Positive semidefinite matrix of numeric values for the quadratic term of a quadratic programming problem. |

`p` |
Vector of numeric values for the linear term of a quadratic programming problem. |

`tol` |
Tolerance used for calculating pseudo-rank of |

Function `nnls`

solves the least squares problem under
nonnegativity (NN) constraints. It is an R interface to the NNLS
function that is described in Lawson and Hanson (1974, 1995). Its
Fortran implementation is public domain and available at
http://www.netlib.org/lawson-hanson/ (with slight
modifications by Yong Wang for compatibility with the lastest
Fortran compiler.)

Given matrix `a`

and vector `b`

, `nnls`

solves the
nonnegativity least squares problem:

*minimize || a x - b ||,*

* subject to x >= 0.*

Function `pnnls`

also solves the above nonnegativity least
squares problem when `k=0`

, but it may also leave the first
`k`

coefficients unrestricted. The output value of `k`

can be smaller than the input one, if `a`

has linearly
dependent columns. If `sum`

is a positive value, `pnnls`

solves the problem by further restricting that the NN-restricted
coefficients must sum to the given value.

Function `pnnqp`

solves the quadratic programming problem

*minimize 0.5 x^T q x +
p^T x,*

when only some or all coefficients are restricted by
nonnegativity. The quadratic programming problem is solved by
transforming the problem into a least squares one under the same
constraints, which is then solved by function
`pnnls`

. Arguments `k`

and `sum`

have the same
meanings as for `pnnls`

.

Functions `nnls`

, `pnnls`

and `pnnqp`

are able to
return any zero-valued solution as 0 exactly. This differs from
functions `lsei`

and `qp`

, which may produce very small
values for exactly 0s, thanks to numerical errors.

`x` |
Solution |

`r` |
The upper-triangular matrix |

`b` |
The vector |

`index` |
Indices of the columns of |

`rnorm` |
Euclidean norm of the residual vector. |

`mode` |
= 1, successful computation; = 2, bad dimensions of the problem; = 3, iteration count exceeded (more than 3 times the number of variables iterations). |

`k` |
Number of the first few coefficients that are truly not NN-restricted. |

Yong Wang <yongwang@auckland.ac.nz>

Lawson and Hanson (1974, 1995). Solving Least Squares Problems. Englewood Cliffs, N.J., Prentice-Hall.

Dax (1990). The smallest point of a polytope. Journal of Optimization Theory and Applications, 64, pp. 429-432.

Wang (2010). Fisher scoring: An interpolation family and its Monte Carlo implementations. Computational Statistics and Data Analysis, 54, pp. 1744-1755.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 | ```
a = matrix(rnorm(40), nrow=10)
b = drop(a %*% c(0,1,-1,1)) + rnorm(10)
nnls(a, b)$x # constraint x >= 0
pnnls(a, b, k=0)$x # same as nnls(a, b)
pnnls(a, b, k=2)$x # first two coeffs are not NN-constrained
pnnls(a, b, k=2, sum=1)$x # NN-constrained coeffs must sum to 1
pnnls(a, b, k=2, sum=2)$x # NN-constrained coeffs must sum to 2
q = crossprod(a)
p = -drop(crossprod(b, a))
pnnqp(q, p, k=2, sum=2)$x # same solution
pnnls(a, b, sum=1)$x # zeros found exactly
pnnqp(q, p, sum=1)$x # zeros found exactly
lsei(a, b, rep(1,4), 1, lower=0) # zeros not so exact
``` |

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.