# fixed.qlessqrFixedpointTypes

Determine fixed-point types for transforming A to R in-place, where R is upper-triangular factor of QR decomposition of A, without computing Q

## Syntax

``T = fixed.qlessqrFixedpointTypes(m,max_abs_A,precisionBits)``

## Description

example

````T = fixed.qlessqrFixedpointTypes(m,max_abs_A,precisionBits)` computes fixed-point types for transforming A to R in-place, where R is the upper-triangular factor of the QR decomposition of A, without computing Q. `T` is returned as a struct with field `T.A` containing a `fi` object that specifies the fixed-point type for A, which guarantees no overflow will occur in the QR algorithm.The QR algorithm transforms A in-place into upper-triangular R, where QR=A is the QR decomposition of A.```

## Examples

collapse all

This example shows how to use `fixed.qlessqrFixedpointTypes` to analytically determine a fixed-point type for the computation of the Q-less QR decomposition.

Define Matrix Dimensions

Specify the number of rows and columns in matrix $A$.

```m = 10; % Number of rows in matrix A n = 3; % Number of columns in matrix A```

Generate Matrix A

Use the helper function `realUniformRandomArray` to generate a random matrix $A$ such that the elements of $A$ are between $-1$ and $+1$.

```rng('default') A = fixed.example.realUniformRandomArray(-1,1,m,n);```

Select Fixed-Point Type

Use the `fixed.qlessqrFixedpointTypes` function to select the fixed-point data type for matrix $A$ that guarantees no overflow will occur in the transformation of $A$ in-place to $R={Q}^{\prime }A$.

```max_abs_A = 1; % Upper bound on max(abs(A(:)) precisionBits = 24; % Number of bits of precision T = fixed.qlessqrFixedpointTypes(m,max_abs_A,precisionBits)```
```T = struct with fields: A: [0x0 embedded.fi] ```

`T.A` is the type computed for transforming $\mathit{A}$ to $\mathit{R}={\mathit{Q}}^{\prime }\mathit{A}$ in-place so that it does not overflow.

`T.A`
```ans = [] DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 28 FractionLength: 24 ```

Use the Specified Type to Compute the Q-less QR Decomposition

Cast the input to the type determined by `fixed.qlessqrFixedpointTypes``.`

`A = cast(A,'like',T.A);`

Accelerate `fixed.qlessQR` by using `fiaccel` to generate a MATLAB executable (MEX) function.

`fiaccel fixed.qlessQR -args {A} -o qlessQR_mex`

Compute the QR decomposition.

`R = qlessQR_mex(A);`

Verify that R is Upper-Triangular

$R$ is an upper-triangular matrix.

`R`
```R = 2.2180 0.8559 -0.5607 0 2.0578 -0.4017 0 0 1.7117 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 28 FractionLength: 24 ```
`isequal(R,triu(R))`
```ans = logical 1 ```

Verify the Accuracy of the Output

To evaluate the accuracy of the `fixed.qlessQR` function, compute the relative error.

$\mathit{R}={\mathit{Q}}^{\prime }\mathit{A}$, and $Q$ is orthogonal, so ${R}^{\prime }R={A}^{\prime }Q{Q}^{\prime }A={A}^{\prime }A$, within rounding error.

`relative_error = norm(double(R'*R - A'*A))/norm(double(A'*A))`
```relative_error = 9.0961e-07 ```

Suppress `mlint` warnings.

`%#ok<*NOPTS>`

## Input Arguments

collapse all

Number of rows in A, specified as a positive integer-valued scalar.

Data Types: `double`

Maximum of the absolute value of A, specified as a scalar.

Example: `max(abs(A(:)))`

Data Types: `double`

Required number of bits of precision, specified as a positive integer-valued scalar.

Data Types: `double`

## Output Arguments

collapse all

Fixed-point type for A, returned as a struct. The struct `T` has field `T.A` that contains a `fi` object that specifies a fixed-point type for A that guarantees no overflow will occur in the QR algorithm.

## Tips

Use `fixed.qlessqrFixedpointTypes` to compute fixed-point types for the inputs of these functions and blocks.

## Algorithms

The number of integer bits required to prevent overflow is derived from the following bound on the growth of R [1]. The required number of integer bits is added to the number of bits of precision, `precisionBits`, of the input, plus one for the sign bit, plus one bit for intermediate CORDIC gain of approximately 1.6468 [2].

The elements of R are bounded in magnitude by

`$\mathrm{max}\left(|R\left(:\right)|\right)\le \sqrt{m}\mathrm{max}\left(|A\left(:\right)|\right).$`

## References

[2] Voler, Jack E. "The CORDIC Trigonometric Computing Technique." IRE Transactions on Electronic Computers EC-8 (1959): 330-334.

Introduced in R2021b

Get trial now