## DOTRIGHTDIVIDE Element-wise Right-Division Operator

Section: Mathematical Operators

### Usage

Divides two numerical arrays (elementwise). There are two forms for its use, both with the same general syntax:

      y = a ./ b

where `a` and `b` are `n`-dimensional arrays of numerical type. In the first case, the two arguments are the same size, in which case, the output `y` is the same size as the inputs, and is the element-wise division of `b` by `a`. In the second case, either `a` or `b` is a scalar, in which case `y` is the same size as the larger argument, and is the division of the scalar with each element of the other argument.

The type of `y` depends on the types of `a` and `b` using type promotion rules, with one important exception: unlike `C`, integer types are promoted to `double` prior to division.

### Function Internals

There are three formulae for the dot-right-divide operator, depending on the sizes of the three arguments. In the most general case, in which the two arguments are the same size, the output is computed via:

If `a` is a scalar, then the output is computed via

On the other hand, if `b` is a scalar, then the output is computed via

### Examples

Here are some examples of using the dot-right-divide operator. First, a straight-forward usage of the `./` operator. The first example is straightforward:

    --> 3 ./ 8
    ans =
      <double>  - size: [1 1]
     0.375

Note that this is not the same as evaluating `3/8` in `C` - there, the output would be `0`, the result of the integer division.

We can also divide complex arguments:

    --> a = 3 + 4*i
    a =
      <complex>  - size: [1 1]
      3+ 4 i
    --> b = 5 + 8*i
    b =
      <complex>  - size: [1 1]
      5+ 8 i
    --> c = a ./ b
    c =
      <complex>  - size: [1 1]
      0.52808988-0.04494382 i

If a `complex` value is divided by a `double`, the result is promoted to `dcomplex`.

    --> b = a ./ 2.0
    b =
      <dcomplex>  - size: [1 1]
     1.5+2.0i

We can also demonstrate the three forms of the dot-right-divide operator. First the element-wise version:

    --> a = [1,2;3,4]
    a =
      <int32>  - size: [2 2]

    Columns 1 to 2
     1  2
     3  4
    --> b = [2,3;6,7]
    b =
      <int32>  - size: [2 2]

    Columns 1 to 2
     2  3
     6  7
    --> c = a ./ b
    c =
      <double>  - size: [2 2]

    Columns 1 to 2
     0.5000000000000000  0.6666666666666666
     0.5000000000000000  0.5714285714285714

Then the scalar versions

    --> c = a ./ 3
    c =
      <double>  - size: [2 2]

    Columns 1 to 2
     0.3333333333333333  0.6666666666666666
     1.0000000000000000  1.3333333333333333
    --> c = 3 ./ a
    c =
      <double>  - size: [2 2]

    Columns 1 to 2
     3.00  1.50
     1.00  0.75