\section{DOTRIGHTDIVIDE Element-wise Right-Division Operator}

\subsection{Usage}

Divides two numerical arrays (elementwise).  There are two forms
for its use, both with the same general syntax:
\begin{verbatim}
  y = a ./ b
\end{verbatim}
where \verb|a| and \verb|b| are \verb|n|-dimensional arrays of numerical type.  In the
first case, the two arguments are the same size, in which case, the 
output \verb|y| is the same size as the inputs, and is the element-wise
division of \verb|b| by \verb|a|.  In the second case, either \verb|a| or \verb|b| is a scalar, 
in which case \verb|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 \verb|y| depends on the types of \verb|a| and \verb|b| using type 
promotion rules, with one important exception: unlike \verb|C|, integer
types are promoted to \verb|double| prior to division.
\subsection{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:
\[
y(m_1,\ldots,m_d) = \frac{a(m_1,\ldots,m_d)}{b(m_1,\ldots,m_d)}
\]
If \verb|a| is a scalar, then the output is computed via
\[
y(m_1,\ldots,m_d) = \frac{a}{b(m_1,\ldots,m_d)}
\]
On the other hand, if \verb|b| is a scalar, then the output is computed via
\[
y(m_1,\ldots,m_d) = \frac{a(m_1,\ldots,m_d)}{b}.
\]
\subsection{Examples}

Here are some examples of using the dot-right-divide operator.  First, a 
straight-forward usage of the \verb|./| operator.  The first example
is straightforward:
\begin{verbatim}
--> 3 ./ 8
ans = 
  <double>  - size: [1 1]
 0.375  

\end{verbatim}
Note that this is not the same as evaluating \verb|3/8| in \verb|C| - there,
the output would be \verb|0|, the result of the integer division.

We can also divide complex arguments:
\begin{verbatim}
--> 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  

\end{verbatim}
If a \verb|complex| value is divided by a \verb|double|, the result is 
promoted to \verb|dcomplex|.
\begin{verbatim}
--> b = a ./ 2.0
b = 
  <dcomplex>  - size: [1 1]
 1.5+2.0i  

\end{verbatim}
We can also demonstrate the three forms of the dot-right-divide operator.  First
the element-wise version:
\begin{verbatim}
--> 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  

\end{verbatim}
Then the scalar versions
\begin{verbatim}
--> 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  

\end{verbatim}
