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 mtxmg_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

       mtxmg_c ( Matrix transpose times matrix, general dimension )

       void mtxmg_c ( const void  * m1,
                      const void  * m2,
                      SpiceInt      nc1,
                      SpiceInt      nr1r2,
                      SpiceInt      nc2,
                      void        * mout  )

#### Abstract

       Multiply the transpose of a matrix with another matrix,
       both of arbitrary size. (The dimensions of the matrices must be
       compatible with this multiplication.)

#### Required_Reading

       None.

#### Keywords

       MATRIX

#### Brief_I/O

       VARIABLE  I/O  DESCRIPTION
       --------  ---  --------------------------------------------------
       m1         I   nr1r2 X nc1 double precision matrix.
       m2         I   nr1r2 X nc2 double precision matrix.
       nc1        I   Column dimension of `m1' and row dimension of `mout'.
       nr1r2      I   Row dimension of `m1' and `m2'.
       nc2        I   Column dimension of `m2' (and also `mout').
       mout       O   Transpose of `m1' times `m2'.

#### 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
                   rows in `m1'.

       nc1         is the number of columns in `m1' and the number of rows
                   of `mout'.

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

       nc2         is the number of columns in both `m2' and `mout'.

#### Detailed_Output

       mout        is the product matrix defined as the transpose of
                   `m1' times `m2', that is

                                 t
                      mout = (m1)  x (m2)

                   where the superscript `t' denotes the transpose of `m1'.

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

                   `mout' may overwrite `m1' or `m2'.

#### Parameters

       None.

#### Exceptions

       1)  If nr1r2 < 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 `nc1', and `j' from 1
       to `nc2':

          mout(i,j) = Summation from k=1 to nr1r2 of  m1(k,i) * 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 2x4 and a 2x3 matrices, multiply the transpose of the
          first matrix by the second one.

          Example code begins here.

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

          int main( )
          {

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

             SpiceInt             i;

             /.
             Define `m1' and `m2'.
             ./
             SpiceDouble          m1     [2][4] = { { 1.0, 2.0, 3.0, 0.0 },
                                                    { 1.0, 1.0, 1.0, 0.0 }  };

             SpiceDouble          m2     [2][3] = { { 1.0, 2.0, 3.0 },
                                                    { 0.0, 0.0, 0.0 } };

             /.
             Multiply the transpose of `m1' by `m2'.
             ./
             mtxmg_c ( m1, m2, 4, 2, 3, mout );

             printf( "Transpose of M1 times M2:\n" );
             for ( i = 0; i < 4; 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:

          Transpose of M1 times M2:
               1.000     2.000     3.000
               2.000     4.000     6.000
               3.000     6.000     9.000
               0.000     0.000     0.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)
       W.M. Owen           (JPL)
       E.D. Wright         (JPL)

#### Version

       -CSPICE Version 1.3.0, 10-AUG-2021 (JDR)

           Changed the input argument names "ncol1" and "ncol2" to "nc1"
           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.2.2, 16-JAN-2008 (EDW)

           Corrected typos in header titles:

           Detailed Input to -Detailed_Input
           Detailed Output to -Detailed_Output

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

           Added -Parameters section header.

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

           Const-qualified input arrays.

       -CSPICE Version 1.0.0, 16-APR-1999 (NJB) (WMO)

#### Index_Entries

       matrix transpose times matrix n-dimensional_case

#### Link to routine mtxmg_c source file mtxmg_c.c

    Fri Dec 31 18:41:09 2021