Index of Functions: A B C D E F G H I J K L M N O P Q R S T U V W X
Index Page mxmg_c
Table of contents
Procedure Abstract Required_Reading Keywords Brief_I/O Detailed_Input | Detailed_Output Parameters Exceptions Files Particulars Examples | Restrictions Literature_References Author_and_Institution Version Index_Entries
#### Procedure
       mxmg_c ( Matrix times matrix, general dimension )

       void mxmg_c ( const void    * m1,
                     const void    * m2,
                     SpiceInt        nr1,
                     SpiceInt        nc1r2,
                     SpiceInt        nc2,
                     void          * mout   )
#### Abstract
       Multiply two double precision matrices of arbitrary size.
#### Required_Reading
       None.
#### Keywords
       MATRIX
#### Brief_I/O
       VARIABLE  I/O  DESCRIPTION
       --------  ---  --------------------------------------------------
       m1         I   nr1   x nc1r2 double precision matrix.
       m2         I   nc1r2 x nc2   double precision matrix.
       nr1        I   Row dimension of `m1' (and also `mout').
       nc1r2      I   Column dimension of `m1' and row dimension of `m2'.
       nc2        I   Column dimension of `m2' (and also `mout').
       mout       O   nr1 x nc2 double precision matrix.
#### Detailed_Input
       m1          is any double precision matrix of arbitrary size.

       m2          is any double precision matrix of arbitrary size.
                   The number of rows in m2 must match the number of
                   columns in m1.

       nr1         is the number of rows in both `m1' and `mout'.

       nc1r2       is the number of columns in `m1' and (by necessity)
                   the number of rows of `m2'.

       nc2         is the number of columns in both `m2' and `mout'.
#### Detailed_Output
       mout        is the product matrix defined by

                      mout = (m1) x (m2)

                   `mout' is a double precision matrix of dimension
                   nr1 x nc2.

                   `mout' may overwrite `m1' or `m2'.
#### Parameters
       None.
#### Exceptions
       1)  If nc1r2 < 0, the elements of the matrix `mout' are set equal to
           zero.

       2)  If memory cannot be allocated to create the temporary matrix
           required for the execution of the routine, the error
           SPICE(MALLOCFAILED) is signaled.
#### Files
       None.
#### Particulars
       The code reflects precisely the following mathematical expression

       For each value of the subscript `i' from 1 to `nr1', and `j' from 1
       to `nc2':

          mout(i,j) = Summation from k=1 to nc1r2 of  m1(i,k) * m2(k,j)
#### Examples
       The numerical results shown for this example may differ across
       platforms. The results depend on the SPICE kernels used as
       input, the compiler and supporting libraries, and the machine
       specific arithmetic implementation.

       1) Given a 3x2 and a 2x3 matrices, multiply the first matrix by
          the second one.

          Example code begins here.

          /.
             Program mxmg_ex1
          ./
          #include <stdio.h>
          #include "SpiceUsr.h"

          int main( )
          {

             /.
             Local variables.
             ./
             SpiceDouble          mout   [3][3];

             SpiceInt             i;

             /.
             Define `m1' and `m2'.
             ./
             SpiceDouble          m1     [3][2] = { { 1.0, 4.0 },
                                                    { 2.0, 5.0 },
                                                    { 3.0, 6.0 }  };

             SpiceDouble          m2     [2][3] = { { 1.0, 3.0, 5.0 },
                                                    { 2.0, 4.0, 6.0 } };

             /.
             Multiply `m1' by `m2'.
             ./
             mxmg_c ( m1, m2, 3, 2, 3, mout );

             printf( "M1 times M2:\n" );
             for ( i = 0; i < 3; i++ )
             {
                printf( "%10.3f %9.3f %9.3f\n",
                        mout[i][0], mout[i][1], mout[i][2] );
             }

             return ( 0 );
          }

          When this program was executed on a Mac/Intel/cc/64-bit
          platform, the output was:

          M1 times M2:
               9.000    19.000    29.000
              12.000    26.000    40.000
              15.000    33.000    51.000
#### Restrictions
       1)  No error checking is performed to prevent numeric overflow or
           underflow.

       2)  No error checking performed to determine if the input and
           output matrices have, in fact, been correctly dimensioned.
#### Literature_References
       None.
#### Author_and_Institution
       N.J. Bachman        (JPL)
       J. Diaz del Rio     (ODC Space)
       E.D. Wright         (JPL)
#### Version
       -CSPICE Version 1.2.0, 10-AUG-2021 (JDR)

           Changed the input argument names "nrow1", "ncol1" and "ncol2" to
           "nr1", "nc1r2" and "nc2" for consistency with other routines.

           Updated short error message for consistency within CSPICE wrapper
           interface: MEMALLOCFAILED -> MALLOCFAILED.

           Edited the header to comply with NAIF standard.
           Added complete code example based on the existing example.

           Added entry #1 to -Exceptions section.

       -CSPICE Version 1.1.2, 16-JAN-2008 (EDW)

           Corrected typos in header titles:

           Detailed Input to -Detailed_Input
           Detailed Output to -Detailed_Output

       -CSPICE Version 1.1.1, 10-NOV-2006 (EDW)

           Added -Parameters section header.

       -CSPICE Version 1.1.0, 28-AUG-2001 (NJB)

           Const-qualified input arrays.

       -CSPICE Version 1.0.0, 16-APR-1999 (NJB)
#### Index_Entries
       matrix times matrix n-dimensional_case
#### Link to routine mxmg_c source file mxmg_c.c

    Fri Dec 31 18:41:09 2021