This routine computes a state transformation from an Euler angle 
   factorization of a rotation and the derivatives of those Euler 
   angles. 

   ROTATION

   VARIABLE  I/O  DESCRIPTION 
   --------  ---  -------------------------------------------------- 
   eulang     I   An array of Euler angles and their derivatives. 
   axisa      I   Axis A of the Euler angle factorization. 
   axisb      I   Axis B of the Euler angle factorization. 
   axisc      I   Axis C of the Euler angle factorization. 
   xform      O   A state transformation matrix. 

   eulang      is the set of Euler angles corresponding to the 
               specified factorization. 

               If we represent r as shown here: 

                   r =  [ alpha ]     [ beta ]     [ gamma ] 
                                 axisa        axisb         axisc 

               then 


                  eulang[0] = alpha 
                  eulang[1] = beta 
                  eulang[2] = gamma 
                  eulang[3] = dalpha/dt 
                  eulang[4] = dbeta/dt 
                  eulang[5] = dgamma/dt 


   axisa       are the axes desired for the factorization of r. 
   axisb       All must be in the range from 1 to 3.  Moreover 
   axisc       it must be the case that axisa and axisb are distinct 
               and that axisb and axisc are distinct. 

               Every rotation matrix can be represented as a product 
               of three rotation matrices about the principal axes 
               of a reference frame. 

                   r =  [ alpha ]     [ beta ]     [ gamma ] 
                                 axisa        axisb         axisc 

               The value 1 corresponds to the X axis. 
               The value 2 corresponds to the Y axis. 
               The value 3 corresponds to the Z axis. 

   xform       is the state transformation corresponding r and dr/dt 
               as described above.  Pictorially, 

                    [       |        ] 
                    |  r    |    0   | 
                    |       |        | 
                    |-------+--------| 
                    |       |        | 
                    | dr/dt |    r   | 
                    [       |        ] 

               where r is a rotation that varies with respect to time 
               and dr/dt is its time derivative. 

   None. 

   This function is intended to provide an inverse for the function 
   xf2eul_c.    


   A word about notation:  the symbol 

      [ x ] 
           i 

   indicates a coordinate system rotation of x radians about the 
   ith coordinate axis.  To be specific, the symbol 

      [ x ] 
           1 

   indicates a coordinate system rotation of x radians about the 
   first, or x-, axis; the corresponding matrix is 

      +-                    -+ 
      |  1      0       0    | 
      |                      | 
      |  0    cos(x)  sin(x) |. 
      |                      | 
      |  0   -sin(x)  cos(x) | 
      +-                    -+ 

   Remember, this is a COORDINATE SYSTEM rotation by x radians; this 
   matrix, when applied to a vector, rotates the vector by -x 
   radians, not x radians.  Applying the matrix to a vector yields 
   the vector's representation relative to the rotated coordinate 
   system. 

   The analogous rotation about the second, or y-, axis is 
   represented by 

      [ x ] 
           2 

   which symbolizes the matrix 

      +-                    -+ 
      | cos(x)   0   -sin(x) | 
      |                      | 
      |  0       1      0    |, 
      |                      | 
      | sin(x)   0    cos(x) | 
      +-                    -+ 

   and the analogous rotation about the third, or z-, axis is 
   represented by 

      [ x ] 
           3 

   which symbolizes the matrix 

      +-                    -+ 
      |  cos(x)  sin(x)   0  | 
      |                      | 
      | -sin(x)  cos(x)   0  |. 
      |                      | 
      |  0        0       1  | 
      +-                    -+ 


   The input matrix is assumed to be the product of three 
   rotation matrices, each one of the form 

      +-                    -+ 
      |  1      0       0    | 
      |                      | 
      |  0    cos(r)  sin(r) |     (rotation of r radians about the 
      |                      |      x-axis), 
      |  0   -sin(r)  cos(r) | 
      +-                    -+ 


      +-                    -+ 
      | cos(s)   0   -sin(s) | 
      |                      | 
      |  0       1      0    |     (rotation of s radians about the 
      |                      |      y-axis), 
      | sin(s)   0    cos(s) | 
      +-                    -+ 

   or 

      +-                    -+ 
      |  cos(t)  sin(t)   0  | 
      |                      | 
      | -sin(t)  cos(t)   0  |     (rotation of t radians about the 
      |                      |      z-axis), 
      |  0        0       1  | 
      +-                    -+ 

   where the second rotation axis is not equal to the first or 
   third.  Any rotation matrix can be factored as a sequence of 
   three such rotations, provided that this last criterion is met. 

   This routine is related to the routine eul2xf_c which produces 
   a state transformation from an input set of axes, Euler angles 
   and derivatives. 

   The two function calls shown here will not change xform except for 
   round off errors. 

      xf2eul_c ( xform,  axisa, axisb, axisc, eulang, &unique );
      eul2xf_c ( eulang, axisa, axisb, axisc, xform           ); 

   On the other hand the two calls 

      eul2xf_c ( eulang, axisa, axisb, axisc, xform           ); 
      xf2eul_c ( xform,  axisa, axisb, axisc, eulang, &unique );

   will leave eulang unchanged only if the components of eulang 
   are in the range produced by xf2eul_c and the Euler representation 
   of the rotation component of xform is unique within that range. 

   Suppose you have a set of Euler angles and their derivatives 
   for a 3 1 3 rotation, and that you would like to determine 
   the equivalent angles and derivatives for a 1 2 3 rotation. 

       r = [alpha]  [beta]  [gamma] 
                  3       1        3 

       r = [roll]  [pitch]  [yaw] 
                 1        2      3 

   The following code fragment will perform the desired computation. 

      abgang[0] = alpha; 
      abgang[1] = beta; 
      abgang[2] = gamma; 
      abgang[3] = dalpha; 
      abgang[4] = dbeta; 
      abgang[5] = dgamma; 

      eul2xf_c ( abgang, 3, 1, 3, xform  ); 
      xf2eul_c ( xform,  1, 2, 3, rpyang ); 

      roll     = rpyang[0]; 
      pitch    = rpyang[1]; 
      yaw      = rpyang[2]; 
      droll    = rpyang[3]; 
      dpitch   = rpyang[4]; 
      dyaw     = rpyang[5];

   None. 

   All erroneous inputs are diagnosed by routines in the call 
   tree to this routine.  These include 

   1)   If any of axisa, axisb, or axisc do not have values in 

           { 1, 2, 3 }, 

        then the error SPICE(INPUTOUTOFRANGE) is signaled. 

   None. 

   N.J. Bachman    (JPL)
   W.L. Taber      (JPL) 

   None. 

   -CSPICE Version 2.0.0, 31-OCT-2005 (NJB)

      Restriction that second axis must differ from the first
      and third was removed.

   -CSPICE Version 1.0.1, 03-JUN-2003 (EDW)

      Correct typo in Procedure line.

   -CSPICE Version 1.0.0, 18-MAY-1999 (WLT) (NJB)

   State transformation from Euler angles and derivatives