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 = 
  <dcomplex>  - size: [1 1]
  3+ 4i  
--> b = 5 + 8*i
b = 
  <dcomplex>  - size: [1 1]
  5+ 8i  
--> c = a ./ b
c = 
  <dcomplex>  - size: [1 1]
  0.5280898876404494-0.0449438202247191i  

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