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
mxv_c

 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

```   mxv_c ( Matrix times vector, 3x3 )

void mxv_c ( ConstSpiceDouble    m   [3][3],
ConstSpiceDouble    vin [3],
SpiceDouble         vout[3]    )

```

#### Abstract

```   Multiply a 3x3 double precision matrix with a 3-dimensional
double precision vector.
```

```   None.
```

#### Keywords

```   MATRIX
VECTOR

```

#### Brief_I/O

```   VARIABLE  I/O  DESCRIPTION
--------  ---  --------------------------------------------------
m          I   3x3 double precision matrix.
vin        I   3-dimensional double precision vector.
vout       O   3-dimensional double precision vector. `vout' is
the product m*vin.
```

#### Detailed_Input

```   m           is an arbitrary 3x3 double precision matrix.

vin         is an arbitrary 3-dimensional double precision vector.
```

#### Detailed_Output

```   vout        is a 3-dimensional double precision vector. `vout' is
the product m * v. `vout' may overwrite `vin'.
```

#### Parameters

```   None.
```

#### Exceptions

```   Error free.
```

#### Files

```   None.
```

#### Particulars

```   The code reflects precisely the following mathematical expression

For each value of the subscript `i' from 0 to 2:

2
.-----
\
vout[i] =   )  m[i][k] * vin[k]
/
'-----
k=0

The intermediate results of the operation performed by this routine
are buffered in a temporary vector which is later moved to the output
vector.  Thus `vout' can be actually be `vin' if desired without
interfering with the computation.
```

#### 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 3x3 matrix and a 3-vector, multiply the matrix by
the vector.

Example code begins here.

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

int main( )
{

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

/.
Define `m' and `vin'.
./
SpiceDouble          m      [3][3] = { { 0.0,  1.0,  0.0},
{-1.0,  0.0,  0.0},
{ 0.0,  0.0,  1.0} };

SpiceDouble          vin    [3] = { 1.0,  2.0,  3.0 };

/.
Multiply `m' by `vin'.
./
mxv_c ( m, vin, vout );

printf( "M times VIN:\n" );
printf( "%10.3f %9.3f %9.3f\n", vout[0], vout[1], vout[2] );

return ( 0 );
}

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

M times VIN:
2.000    -1.000     3.000
```

#### Restrictions

```   1)  The user is responsible for checking the magnitudes of the
elements of `m' and `vin' so that a floating point overflow does
not occur.
```

#### Literature_References

```   None.
```

#### Author_and_Institution

```   J. Diaz del Rio     (ODC Space)
E.D. Wright         (JPL)
```

#### Version

```   -CSPICE Version 1.1.0, 13-AUG-2021 (JDR)

Changed input argument name "m1" to "m" for consistency with
other routines.

```   matrix times 3-dimensional vector
`Fri Dec 31 18:41:09 2021`