Note: This page has been translated by MathWorks. Please click here

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

Round `fi`

object toward nearest integer
or round input data using `quantizer`

object

`y = round(a)`

y = round(q,x)

`y = round(a)`

rounds `fi`

object `a`

to
the nearest integer. In the case of a tie, `round`

rounds
values to the nearest integer with greater absolute value. The rounded
value is returned in `fi`

object `y`

.

`y`

and `a`

have the same `fimath`

object
and `DataType`

property.

When the `DataType`

of `a`

is `single`

, `double`

,
or `boolean`

, the `numerictype`

of `y`

is
the same as that of `a`

.

When the fraction length of `a`

is zero or
negative, `a`

is already an integer, and the `numerictype`

of `y`

is
the same as that of `a`

.

When the fraction length of `a`

is positive,
the fraction length of `y`

is 0, its sign is the
same as that of `a`

, and its word length is the difference
between the word length and the fraction length of `a`

,
plus one bit. If `a`

is signed, then the minimum
word length of `y`

is 2. If `a`

is
unsigned, then the minimum word length of `y`

is
1.

For complex `fi`

objects, the imaginary and
real parts are rounded independently.

`round`

does not support `fi`

objects
with nontrivial slope and bias scaling. Slope and bias scaling is
trivial when the slope is an integer power of 2 and the bias is 0.

`y = round(q,x)`

uses the `RoundingMethod`

and `FractionLength`

settings
of `q`

to round the numeric data `x`

,
but does not check for overflows during the operation. Input `x`

must
be a builtin numeric variable. Use the `cast`

function
to work with `fi`

objects.

The following example demonstrates how the `round`

function
affects the `numerictype`

properties of a signed `fi`

object
with a word length of 8 and a fraction length of 3.

a = fi(pi, 1, 8, 3) a = 3.1250 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 8 FractionLength: 3 y = round(a) y = 3 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 6 FractionLength: 0

The following example demonstrates how the `round`

function
affects the `numerictype`

properties of a signed `fi`

object
with a word length of 8 and a fraction length of 12.

a = fi(0.025,1,8,12) a = 0.0249 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 8 FractionLength: 12 y = round(a) y = 0 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 2 FractionLength: 0

The functions `convergent`

, `nearest`

and `round`

differ
in the way they treat values whose least significant digit is 5:

The

`convergent`

function rounds ties to the nearest even integerThe

`nearest`

function rounds ties to the nearest integer toward positive infinityThe

`round`

function rounds ties to the nearest integer with greater absolute value

The following table illustrates these differences for a given `fi`

object `a`

.

a | convergent(a) | nearest(a) | round(a) |
---|---|---|---|

–3.5 | –4 | –3 | –4 |

–2.5 | –2 | –2 | –3 |

–1.5 | –2 | –1 | –2 |

–0.5 | 0 | 0 | –1 |

0.5 | 0 | 1 | 1 |

1.5 | 2 | 2 | 2 |

2.5 | 2 | 3 | 3 |

3.5 | 4 | 4 | 4 |

Create a quantizer object, and use it to quantize input data. The quantizer object applies its properties to the input data to return quantized output.

q = quantizer('fixed', 'convergent', 'wrap', [3 2]); x = (-2:eps(q)/4:2)'; y = round(q,x); plot(x,[x,y],'.-'); axis square;

Applying quantizer object q to the data resulted in a staircase-shape output plot. Linear data input results in output where y shows distinct quantization levels.

Was this topic helpful?