# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English verison of the page.

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

# rdivide

Right-array division (./)

## Syntax

`c = rdivide(a,b)c = a./b`

## Description

`c = rdivide(a,b)` and `c = a./b` perform right-array division by dividing each element of `a` by the corresponding element of `b`. If inputs `a` and `b` are not the same size, one of them must be a scalar value.

The numerator input `a` can be complex, but the denominator `b` requires a real-valued input. If `a` is complex, the real and imaginary parts of `a` are independently divided by `b`.

The following table shows the rules used to assign property values to the output of the `rdivide` function.

Output PropertyRule
`Signedness`

If either input is `Signed`, the output is `Signed`.

If both inputs are `Unsigned`, the output is `Unsigned`.

`WordLength`

The output word length equals the maximum of the input word lengths.

`FractionLength`

For `c = a./b`, the fraction length of output `c` equals the fraction length of `a` minus the fraction length of `b`.

The following table shows the rules the `rdivide` function uses to handle inputs with different data types.

CaseRule
Interoperation of `fi` objects and built-in integers

Built-in integers are treated as fixed-point objects.

For example, `B = int8(2)` is treated as an `s8,0` `fi` object.

Interoperation of `fi` objects and constants

MATLAB® for code generation treats constant integers as fixed-point objects with the same word length as the `fi` object and a fraction length of `0`.

Interoperation of mixed data types

Similar to all other `fi` object functions, when inputs `a` and `b` have different data types, the data type with the higher precedence determines the output data type. The order of precedence is as follows:

1. `ScaledDouble`

2. `Fixed-point`

3. Built-in `double`

4. Built-in `single`

When both inputs are `fi` objects, the only data types that are allowed to mix are `ScaledDouble` and `Fixed-point`.

## Examples

In this example, you perform right-array division on a 3-by-3 magic square of `fi` objects. Each element of the 3-by-3 magic square is divided by the corresponding element in the 3-by-3 input array `b`.

```a = fi(magic(3)) b = int8([3 3 4; 1 2 4 ; 3 1 2 ]) c = a./b```

The `mrdivide` function outputs a 3-by-3 array of signed `fi` objects, each of which has a word length of 16 bits and fraction length of 11 bits.

```a = 8 1 6 3 5 7 4 9 2 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 16 FractionLength: 11 b = 3 3 4 1 2 4 3 1 2 c = 2.6665 0.3335 1.5000 3.0000 2.5000 1.7500 1.3335 9.0000 1.0000 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 16 FractionLength: 11 ```