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 vprojg_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
       vprojg_c ( Vector projection, general dimension )

       void vprojg_c ( ConstSpiceDouble    a      [],
                       ConstSpiceDouble    b      [],
                       SpiceInt            ndim,
                       SpiceDouble         p      [] )
#### Abstract
       Compute the projection of one vector onto another vector. All
       vectors are of arbitrary dimension.
#### Required_Reading
       None.
#### Keywords
       VECTOR
#### Brief_I/O
       VARIABLE  I/O  DESCRIPTION
       --------  ---  --------------------------------------------------
       a          I   The vector to be projected.
       b          I   The vector onto which `a' is to be projected.
       ndim       I   Dimension of `a', `b', and `p'.
       p          O   The projection of `a' onto `b'.
#### Detailed_Input
       a           is a double precision vector of arbitrary dimension.
                   This vector is to be projected onto the vector `b'.

       b           is a double precision vector of arbitrary dimension.
                   This vector is the vector which receives the
                   projection.

       ndim        is the dimension of `a', `b' and `p'.
#### Detailed_Output
       p           is a double precision vector of arbitrary dimension
                   containing the projection of `a' onto `b'. (`p' is
                   necessarily parallel to `b'.)
#### Parameters
       None.
#### Exceptions
       Error free.
#### Files
       None.
#### Particulars
       The projection of a vector `a' onto a vector `b' is, by definition,
       that component of `a' which is parallel to `b'. To find this
       component it is enough to find the scalar ratio of the length of
       `b' to the projection of `a' onto `b', and then use this number to
       scale the length of `b'. This ratio is given by

           ratio = < a, b > / < b, b >

       where <,> denotes the general vector dot product. This routine
       does not attempt to divide by zero in the event that `b' is the
       zero vector.
#### 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) Define two sets of vectors and compute the projection of
          each vector of the first set on the corresponding vector of
          the second set.

          Example code begins here.

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

          int main( )
          {

             /.
             Local parameters.
             ./
             #define NDIM         4
             #define SETSIZ       4

             /.
             Local variables.
             ./
             SpiceDouble          pvec   [NDIM];

             SpiceInt             i;

             /.
             Define the two vector sets.
             ./
             SpiceDouble          seta   [SETSIZ][NDIM] = {
                                       {6.0,  6.0,  6.0,  0.0},
                                       {6.0,  6.0,  6.0,  0.0},
                                       {6.0,  6.0,  0.0,  0.0},
                                       {6.0,  0.0,  0.0,  0.0} };

             SpiceDouble          setb   [SETSIZ][NDIM] = {
                                       {2.0,  0.0,  0.0,  0.0},
                                       {-3.0,  0.0,  0.0,  0.0},
                                       {0.0,  7.0,  0.0,  0.0},
                                       {0.0,  0.0,  9.0,  0.0} };

             /.
             Calculate the projection
             ./
             for ( i = 0; i < SETSIZ; i++ )
             {

                vprojg_c ( seta[i], setb[i], NDIM, pvec );
                printf( "Vector A  :  %4.1f %4.1f %4.1f %4.1f\n",
                        seta[i][0], seta[i][1], seta[i][2], seta[i][3] );
                printf( "Vector B  :  %4.1f %4.1f %4.1f %4.1f\n",
                        setb[i][0], setb[i][1], setb[i][2], setb[i][3] );
                printf( "Projection:  %4.1f %4.1f %4.1f %4.1f\n",
                               pvec[0], pvec[1], pvec[2], pvec[3] );
                printf( " \n" );

             }

             return ( 0 );
          }

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

          Vector A  :   6.0  6.0  6.0  0.0
          Vector B  :   2.0  0.0  0.0  0.0
          Projection:   6.0  0.0  0.0  0.0

          Vector A  :   6.0  6.0  6.0  0.0
          Vector B  :  -3.0  0.0  0.0  0.0
          Projection:   6.0 -0.0 -0.0 -0.0

          Vector A  :   6.0  6.0  0.0  0.0
          Vector B  :   0.0  7.0  0.0  0.0
          Projection:   0.0  6.0  0.0  0.0

          Vector A  :   6.0  0.0  0.0  0.0
          Vector B  :   0.0  0.0  9.0  0.0
          Projection:   0.0  0.0  0.0  0.0
#### Restrictions
       1)  No error detection or recovery schemes are incorporated into
           this routine except to insure that no attempt is made to
           divide by zero. Thus, the user is required to make sure that
           the vectors `a' and `b' are such that no floating point overflow
           will occur when the dot products are calculated.
#### Literature_References
       [1]  G. Thomas and R. Finney, "Calculus and Analytic Geometry,"
            7th Edition, Addison Wesley, 1988.
#### Author_and_Institution
       J. Diaz del Rio     (ODC Space)
#### Version
       -CSPICE Version 1.0.0, 01-NOV-2021 (JDR)
#### Index_Entries
       n-dimensional vector projection
#### Link to routine vprojg_c source file vprojg_c.c

    Fri Dec 31 18:41:15 2021