\section{TIMES Matrix Multiply Operator}

\subsection{Usage}

Multiplies two numerical arrays.  This operator is really a combination
of three operators, all of which have the same general syntax:
\begin{verbatim}
  y = a * b
\end{verbatim}
where \verb|a| and \verb|b| are arrays of numerical type.  The result \verb|y| depends
on which of the following three situations applies to the arguments
\verb|a| and \verb|b|:
\begin{enumerate}
\item  \verb|a| is a scalar, \verb|b| is an arbitrary \verb|n|-dimensional numerical array, in which case the output is the element-wise product of \verb|b| with the scalar \verb|a|.

\item  \verb|b| is a scalar, \verb|a| is an arbitrary \verb|n|-dimensional numerical array, in which case the output is the element-wise product of \verb|a| with the scalar \verb|b|.

\item  \verb|a,b| are conformant matrices, i.e., \verb|a| is of size \verb|M x K|, and \verb|b| is of size \verb|K x N|, in which case the output is of size \verb|M x N| and is the matrix product of \verb|a|, and \verb|b|.

\end{enumerate}
The output follows the standard type promotion rules, although in the first two cases, if \verb|a| and \verb|b| are integers, the output is an integer also, while in the third case if \verb|a| and \verb|b| are integers, ,the output is of type \verb|double|.
\subsection{Function Internals}

There are three formulae for the times operator.  For the first form
\[
y(m_1,\ldots,m_d) = a \times b(m_1,\ldots,m_d),
\]
and the second form
\[
y(m_1,\ldots,m_d) = a(m_1,\ldots,m_d) \times b.
\]
In the third form, the output is the matrix product of the arguments
\[
y(m,n) = \sum_{k=1}^{K} a(m,k) b(k,n)
\]
\subsection{Examples}

Here are some examples of using the matrix multiplication operator.  First,
the scalar examples (types 1 and 2 from the list above):
\begin{verbatim}
--> a = [1,3,4;0,2,1]
a = 
  <int32>  - size: [2 3]
 
Columns 1 to 3
 1  3  4  
 0  2  1  
--> b = a * 2
b = 
  <int32>  - size: [2 3]
 
Columns 1 to 3
 2  6  8  
 0  4  2  

\end{verbatim}
The matrix form, where the first argument is \verb|2 x 3|, and the
second argument is \verb|3 x 1|, so that the product is size 
\verb|2 x 1|.
\begin{verbatim}
--> a = [1,2,0;4,2,3]
a = 
  <int32>  - size: [2 3]
 
Columns 1 to 3
 1  2  0  
 4  2  3  
--> b = [5;3;1]
b = 
  <int32>  - size: [3 1]
 
Columns 1 to 1
 5  
 3  
 1  
--> c = a*b
c = 
  <double>  - size: [2 1]
 
Columns 1 to 1
 11  
 29  

\end{verbatim}
Note that the output is double precision.
