## Class NormOps

- java.lang.Object
- org.ejml.ops.NormOps

public class NormOpsextends Object

Norms are a measure of the size of a vector or a matrix. One typical application is in error analysis.

Vector norms have the following properties:

- ||x|| > 0 if x ≠ 0 and ||0|| = 0
- ||αx|| = |α| ||x||
- ||x+y|| ≤ ||x|| + ||y||

Matrix norms have the following properties:

- ||A|| > 0 if A ≠ 0 where A ∈ ℜ
^{m × n} - || α A || = |α| ||A|| where A ∈ ℜ
^{m × n} - ||A+B|| ≤ ||A|| + ||B|| where A and B are ∈ ℜ
^{m × n} - ||AB|| ≤ ||A|| ||B|| where A and B are ∈ ℜ
^{m × m}

Matrix norms can be induced from vector norms as is shown below:

||A||_{M}= max_{x≠0}||Ax||_{v}/||x||_{v}

where ||.||_{M}is the induced matrix norm for the vector norm ||.||_{v}.By default implementations that try to mitigate overflow/underflow are used. If the word fast is found before a function's name that means it does not mitigate those issues, but runs a bit faster.

### Constructor Summary

Constructors Constructor and Description **NormOps**()

### Method Summary

Methods Modifier and Type Method and Description `static double`

**conditionP**(DenseMatrix64F A, double p)The condition number of a matrix is used to measure the sensitivity of the linear system**Ax=b**.`static double`

**conditionP2**(DenseMatrix64F A)The condition p = 2 number of a matrix is used to measure the sensitivity of the linear system**Ax=b**.`static double`

**elementP**(RowD1Matrix64F A, double p)Element wise p-norm:

norm = {∑_{i=1:m}∑_{j=1:n}{ |a_{ij}|^{p}}}^{1/p}`static double`

**fastElementP**(D1Matrix64F A, double p)Same as`elementP(org.ejml.data.RowD1Matrix64F, double)`

but runs faster by not mitigating overflow/underflow related problems.`static double`

**fastNormF**(D1Matrix64F a)This implementation of the Frobenius norm is a straight forward implementation and can be susceptible for overflow/underflow issues.`static double`

**fastNormP**(DenseMatrix64F A, double p)An unsafe but faster version of`normP(org.ejml.data.DenseMatrix64F, double)`

that calls routines which are faster but more prone to overflow/underflow problems.`static double`

**fastNormP2**(DenseMatrix64F A)Computes the p=2 norm.`static double`

**inducedP1**(DenseMatrix64F A)Computes the induced p = 1 matrix norm.

||A||_{1}= max(j=1 to n; sum(i=1 to m; |a_{ij}|))`static double`

**inducedP2**(DenseMatrix64F A)Computes the induced p = 2 matrix norm, which is the largest singular value.`static double`

**inducedPInf**(DenseMatrix64F A)Induced matrix p = infinity norm.

||A||_{∞}= max(i=1 to m; sum(j=1 to n; |a_{ij}|))`static void`

**normalizeF**(DenseMatrix64F A)Normalizes the matrix such that the Frobenius norm is equal to one.`static double`

**normF**(D1Matrix64F a)Computes the Frobenius matrix norm:

normF = Sqrt{ ∑_{i=1:m}∑_{j=1:n}{ a_{ij}^{2}} }`static double`

**normP**(DenseMatrix64F A, double p)Computes either the vector p-norm or the induced matrix p-norm depending on A being a vector or a matrix respectively.`static double`

**normP1**(DenseMatrix64F A)Computes the p=1 norm.`static double`

**normP2**(DenseMatrix64F A)Computes the p=2 norm.`static double`

**normPInf**(DenseMatrix64F A)Computes the p=∞ norm.

### Method Detail

#### normalizeF

public static void normalizeF(DenseMatrix64F A)

Normalizes the matrix such that the Frobenius norm is equal to one.- Parameters:
`A`

- The matrix that is to be normalized.

#### conditionP

public static double conditionP(DenseMatrix64F A, double p)

The condition number of a matrix is used to measure the sensitivity of the linear system

**Ax=b**. A value near one indicates that it is a well conditioned matrix.

κ_{p}= ||A||_{p}||A^{-1}||_{p}If the matrix is not square then the condition of either A

^{T}A or AA^{T}is computed.- Parameters:
`A`

- The matrix.`p`

- p-norm- Returns:
- The condition number.

#### conditionP2

public static double conditionP2(DenseMatrix64F A)

The condition p = 2 number of a matrix is used to measure the sensitivity of the linear system

**Ax=b**. A value near one indicates that it is a well conditioned matrix.

κ_{2}= ||A||_{2}||A^{-1}||_{2}This is also known as the spectral condition number.

- Parameters:
`A`

- The matrix.- Returns:
- The condition number.

#### fastNormF

public static double fastNormF(D1Matrix64F a)

This implementation of the Frobenius norm is a straight forward implementation and can be susceptible for overflow/underflow issues. A more resilient implementation is

`normF(org.ejml.data.D1Matrix64F)`

.- Parameters:
`a`

- The matrix whose norm is computed. Not modified.

#### normF

public static double normF(D1Matrix64F a)

Computes the Frobenius matrix norm:

normF = Sqrt{ ∑_{i=1:m}∑_{j=1:n}{ a_{ij}^{2}} }This is equivalent to the element wise p=2 norm. See

`fastNormF(org.ejml.data.D1Matrix64F)`

for another implementation that is faster, but more prone to underflow/overflow errors.- Parameters:
`a`

- The matrix whose norm is computed. Not modified.- Returns:
- The norm's value.

#### elementP

public static double elementP(RowD1Matrix64F A, double p)

Element wise p-norm:

norm = {∑_{i=1:m}∑_{j=1:n}{ |a_{ij}|^{p}}}^{1/p}This is not the same as the induced p-norm used on matrices, but is the same as the vector p-norm.

- Parameters:
`A`

- Matrix. Not modified.`p`

- p value.- Returns:
- The norm's value.

#### fastElementP

public static double fastElementP(D1Matrix64F A, double p)

Same as`elementP(org.ejml.data.RowD1Matrix64F, double)`

but runs faster by not mitigating overflow/underflow related problems.- Parameters:
`A`

- Matrix. Not modified.`p`

- p value.- Returns:
- The norm's value.

#### normP

public static double normP(DenseMatrix64F A, double p)

Computes either the vector p-norm or the induced matrix p-norm depending on A being a vector or a matrix respectively.- Parameters:
`A`

- Vector or matrix whose norm is to be computed.`p`

- The p value of the p-norm.- Returns:
- The computed norm.

#### fastNormP

public static double fastNormP(DenseMatrix64F A, double p)

An unsafe but faster version of`normP(org.ejml.data.DenseMatrix64F, double)`

that calls routines which are faster but more prone to overflow/underflow problems.- Parameters:
`A`

- Vector or matrix whose norm is to be computed.`p`

- The p value of the p-norm.- Returns:
- The computed norm.

#### normP1

public static double normP1(DenseMatrix64F A)

Computes the p=1 norm. If A is a matrix then the induced norm is computed.- Parameters:
`A`

- Matrix or vector.- Returns:
- The norm.

#### normP2

public static double normP2(DenseMatrix64F A)

Computes the p=2 norm. If A is a matrix then the induced norm is computed.- Parameters:
`A`

- Matrix or vector.- Returns:
- The norm.

#### fastNormP2

public static double fastNormP2(DenseMatrix64F A)

Computes the p=2 norm. If A is a matrix then the induced norm is computed. This implementation is faster, but more prone to buffer overflow or underflow problems.- Parameters:
`A`

- Matrix or vector.- Returns:
- The norm.

#### normPInf

public static double normPInf(DenseMatrix64F A)

Computes the p=∞ norm. If A is a matrix then the induced norm is computed.- Parameters:
`A`

- Matrix or vector.- Returns:
- The norm.

#### inducedP1

public static double inducedP1(DenseMatrix64F A)

Computes the induced p = 1 matrix norm.

||A||_{1}= max(j=1 to n; sum(i=1 to m; |a_{ij}|))- Parameters:
`A`

- Matrix. Not modified.- Returns:
- The norm.

#### inducedP2

public static double inducedP2(DenseMatrix64F A)

Computes the induced p = 2 matrix norm, which is the largest singular value.

- Parameters:
`A`

- Matrix. Not modified.- Returns:
- The norm.

#### inducedPInf

public static double inducedPInf(DenseMatrix64F A)

Induced matrix p = infinity norm.

||A||_{∞}= max(i=1 to m; sum(j=1 to n; |a_{ij}|))- Parameters:
`A`

- A matrix.- Returns:
- the norm.

**SCaVis 2.0 © jWork.ORG**