SpiceZim.h
上传用户:center1979
上传日期:2022-07-26
资源大小:50633k
文件大小:53k
源码类别:

OpenGL

开发平台:

Visual C++

  1. /*
  2. -Header_File SpiceZim.h ( CSPICE interface macros )
  3. -Abstract
  4.    Define interface macros to be called in place of CSPICE 
  5.    user-interface-level functions.  These macros are generally used
  6.    to compensate for compiler deficiencies.
  7.    
  8. -Disclaimer
  9.    THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE
  10.    CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S.
  11.    GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE
  12.    ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE
  13.    PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS"
  14.    TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY
  15.    WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A
  16.    PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC
  17.    SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE
  18.    SOFTWARE AND RELATED MATERIALS, HOWEVER USED.
  19.    IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA
  20.    BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT
  21.    LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  22.    INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS,
  23.    REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE
  24.    REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY.
  25.    RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF
  26.    THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY
  27.    CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE
  28.    ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE.
  29. -Required_Reading
  30.    None.
  31. -Literature_References
  32.    None.
  33. -Particulars
  34.    This header file defines interface macros to be called in place of 
  35.    CSPICE user-interface-level functions.  Currently, the sole purpose
  36.    of these macros is to implement automatic type casting under some 
  37.    environments that generate compile-time warnings without the casts.
  38.    The typical case that causes a problem is a function argument list
  39.    containing an input formal argument of type
  40.    
  41.       const double [3][3]
  42.       
  43.    Under some compilers, a non-const actual argument supplied in a call
  44.    to such a function will generate a spurious warning due to the 
  45.    "mismatched" type.  These macros generate type casts that will
  46.    make such compilers happy.
  47.    
  48.    Examples of compilers that generate warnings of this type are
  49.    
  50.       gcc version 2.2.2, hosted on NeXT workstations running 
  51.       NeXTStep 3.3
  52.       
  53.       Sun C compiler, version 4.2, running under Solaris.
  54.             
  55.       
  56. -Author_and_Institution
  57.    N.J. Bachman       (JPL)
  58.    E.D. Wright        (JPL)
  59. -Version
  60.    -CSPICE Version 9.0.0, 31-OCT-2005 (NJB) 
  61.        Added macros for 
  62.           qdq2av_c
  63.           qxq_c
  64.    -CSPICE Version 8.0.0, 23-FEB-2004 (NJB) 
  65.        Added macro for 
  66.           dafrs_c
  67.    -CSPICE Version 7.0.0, 23-FEB-2004 (EDW) 
  68.        Added macro for 
  69.           srfxpt_c
  70.    -CSPICE Version 6.0.1, 25-FEB-2003 (EDW) (NJB)
  71.        Remove duplicate macro definitions for ekaced_c and 
  72.        ekacei_c. Visual Studio errored out when compiling
  73.        code that included SpiceZim.h.  
  74.        Added macro for 
  75.           dasac_c
  76.    -CSPICE Version 6.0.0, 17-AUG-2002 (NJB) 
  77.        Added macros for
  78.           bschoc_c
  79.           bschoi_c
  80.           bsrchc_c
  81.           bsrchd_c
  82.           bsrchi_c
  83.           esrchc_c
  84.           isordv_c
  85.           isrchc_c
  86.           isrchd_c
  87.           isrchi_c
  88.           lstltc_c
  89.           lstltd_c
  90.           lstlti_c
  91.           lstlec_c
  92.           lstled_c
  93.           lstlei_c
  94.           orderc_c
  95.           orderd_c
  96.           orderi_c
  97.           reordc_c
  98.           reordd_c
  99.           reordi_c
  100.           reordl_c
  101.           spkw18_c
  102.             
  103.    -CSPICE Version 5.0.0, 28-AUG-2001 (NJB) 
  104.        Added macros for
  105.             
  106.           conics_c
  107.           illum_c
  108.           invort_c
  109.           pdpool_c
  110.           prop2b_c
  111.           q2m_c
  112.           spkuds_c
  113.           xposeg_c
  114.           
  115.    -CSPICE Version 4.0.0, 22-MAR-2000 (NJB) 
  116.        Added macros for
  117.        
  118.           spkw12_c
  119.           spkw13_c
  120.        
  121.    -CSPICE Version 3.0.0, 27-AUG-1999 (NJB) (EDW)
  122.        Fixed cut & paste error in macro nvp2pl_c.
  123.        
  124.        Added macros for
  125.        
  126.           axisar_c
  127.           cgv2el_c
  128.           dafps_c
  129.           dafus_c
  130.           diags2_c
  131.           dvdot_c
  132.           dvhat_c
  133.           edlimb_c
  134.           ekacli_c
  135.           ekacld_c
  136.           ekacli_c
  137.           eul2xf_c
  138.           el2cgv_c
  139.           getelm_c
  140.           inedpl_c
  141.           isrot_c
  142.           mequ_c
  143.           npedln_c
  144.           nplnpt_c
  145.           rav2xf_c
  146.           raxisa_c
  147.           saelgv_c
  148.           spk14a_c
  149.           spkapo_c
  150.           spkapp_c
  151.           spkw02_c
  152.           spkw03_c
  153.           spkw05_c
  154.           spkw08_c
  155.           spkw09_c
  156.           spkw10_c
  157.           spkw15_c
  158.           spkw17_c
  159.           sumai_c
  160.           trace_c
  161.           vadd_g
  162.           vhatg_c
  163.           vlcomg_c
  164.           vminug_c
  165.           vrel_c
  166.           vrelg_c
  167.           vsepg_c
  168.           vtmv_c
  169.           vtmvg_c
  170.           vupack_c
  171.           vzerog_c
  172.           xf2eul_c
  173.           xf2rav_c
  174.        
  175.    -CSPICE Version 2.0.0, 07-MAR-1999 (NJB)  
  176.        Added macros for
  177.        
  178.           inrypl_c
  179.           nvc2pl_c
  180.           nvp2pl_c
  181.           pl2nvc_c
  182.           pl2nvp_c
  183.           pl2psv_c
  184.           psv2pl_c
  185.           vprjp_c
  186.           vprjpi_c
  187.    -CSPICE Version 1.0.0, 24-JAN-1999 (NJB) (EDW)
  188. -Index_Entries
  189.    interface macros for CSPICE functions
  190. */
  191. /*
  192. Include Files:
  193. */
  194. #ifndef  HAVE_SPICEDEFS_H
  195. #include "SpiceZdf.h"
  196. #endif
  197. #ifndef HAVE_SPICEIFMACROS_H
  198. #define HAVE_SPICEIFMACROS_H
  199. /*
  200. Macros used to abbreviate type casts:
  201. */
  202.    
  203.    #define  CONST_BOOL         ( ConstSpiceBoolean   *      )
  204.    #define  CONST_ELLIPSE      ( ConstSpiceEllipse   *      )
  205.    #define  CONST_IVEC         ( ConstSpiceInt       *      )
  206.    #define  CONST_MAT          ( ConstSpiceDouble   (*) [3] )
  207.    #define  CONST_MAT2         ( ConstSpiceDouble   (*) [2] )
  208.    #define  CONST_MAT6         ( ConstSpiceDouble   (*) [6] )
  209.    #define  CONST_PLANE        ( ConstSpicePlane     *      )
  210.    #define  CONST_VEC3         ( ConstSpiceDouble   (*) [3] )
  211.    #define  CONST_VEC4         ( ConstSpiceDouble   (*) [4] )
  212.    #define  CONST_STR          ( ConstSpiceChar      *      )
  213.    #define  CONST_VEC          ( ConstSpiceDouble    *      )
  214.    #define  CONST_VOID         ( const void          *      )
  215. /*
  216. Macros that substitute for function calls:
  217. */
  218.    #define  axisar_c( axis, angle, r )                                 
  219.                                                                        
  220.         (   axisar_c( CONST_VEC(axis), (angle), (r) )   )
  221.  
  222.    #define  bschoc_c( value, ndim, lenvals, array, order )             
  223.                                                                        
  224.         (   bschoc_c ( CONST_STR(value),  (ndim),          (lenvals),  
  225.                        CONST_VOID(array), CONST_IVEC(order)          ) )
  226.    #define  bschoi_c( value, ndim, array, order )                      
  227.                                                                        
  228.         (   bschoi_c ( (value)         ,  (ndim),                      
  229.                        CONST_IVEC(array), CONST_IVEC(order) )  )
  230.    #define  bsrchc_c( value, ndim, lenvals, array )                    
  231.                                                                        
  232.         (   bsrchc_c ( CONST_STR(value),  (ndim),  (lenvals),          
  233.                        CONST_VOID(array)                      ) )
  234.    #define  bsrchd_c( value, ndim, array )                             
  235.                                                                        
  236.         (   bsrchd_c( (value),  (ndim),  CONST_VEC(array) )  )
  237.    #define  bsrchi_c( value, ndim, array )                             
  238.                                                                        
  239.         (   bsrchi_c( (value),  (ndim),  CONST_IVEC(array) )  )
  240.    #define  ckw01_c( handle, begtim, endtim, inst,  ref, avflag,       
  241.                      segid,  nrec,   sclkdp, quats, avvs        )      
  242.                                                                        
  243.         (   ckw01_c ( (handle),          (begtim),        (endtim),    
  244.                       (inst),            CONST_STR(ref),  (avflag),    
  245.                       CONST_STR(segid),  (nrec),                       
  246.                       CONST_VEC(sclkdp), CONST_VEC4(quats),            
  247.                       CONST_VEC3(avvs)                            )  )
  248.    #define  ckw02_c( handle, begtim, endtim, inst,  ref,   segid,      
  249.                      nrec,   start,  stop,  quats,  avvs,  rates )     
  250.                                                                        
  251.         (   ckw02_c ( (handle),          (begtim),        (endtim),    
  252.                       (inst),            CONST_STR(ref),               
  253.                       CONST_STR(segid),  (nrec),                       
  254.                       CONST_VEC(start),  CONST_VEC(stop),              
  255.                       CONST_VEC4(quats), CONST_VEC3(avvs),             
  256.                       CONST_VEC(rates)                             )  )
  257.    #define  ckw03_c( handle, begtim, endtim, inst,  ref,  avflag,      
  258.                      segid,  nrec,   sclkdp, quats, avvs, nints,       
  259.                      starts                                       )    
  260.                                                                        
  261.         (   ckw03_c ( (handle),          (begtim),        (endtim),    
  262.                       (inst),            CONST_STR(ref),  (avflag),    
  263.                       CONST_STR(segid),  (nrec),                       
  264.                       CONST_VEC(sclkdp), CONST_VEC4(quats),            
  265.                       CONST_VEC3(avvs),  (nints),                      
  266.                       CONST_VEC(starts)                            )  )
  267.    #define  ckw05_c( handle, subtyp, degree, begtim, endtim, inst,     
  268.                      ref,    avflag, segid,  n,      sclkdp, packts,   
  269.                      rate,    nints, starts                          ) 
  270.                                                                        
  271.         (   ckw05_c ( (handle),          (subtyp),        (degree),    
  272.                       (begtim),          (endtim),                     
  273.                       (inst),            CONST_STR(ref),  (avflag),    
  274.                       CONST_STR(segid),  (n),                          
  275.                       CONST_VEC(sclkdp), CONST_VOID(packts),           
  276.                       (rate),            (nints),                      
  277.                       CONST_VEC(starts)                            )  )
  278.    #define  cgv2el_c( center, vec1, vec2, ellipse )                    
  279.                                                                        
  280.         (   cgv2el_c( CONST_VEC(center), CONST_VEC(vec1),              
  281.                       CONST_VEC(vec2),   (ellipse)        )   )
  282.                       
  283.    #define  conics_c( elts, et, state )                                
  284.                                                                        
  285.         (   conics_c( CONST_VEC(elts), (et), (state) )  )           
  286.    #define  dafps_c( nd, ni, dc, ic, sum )                             
  287.                                                                        
  288.         (   dafps_c ( (nd), (ni), CONST_VEC(dc), CONST_IVEC(ic),       
  289.                       (sum)                                     )   )
  290.    #define  dafrs_c( sum )                                             
  291.                                                                        
  292.         (   dafrs_c ( CONST_VEC( sum )  )   )
  293.    #define  dafus_c( sum, nd, ni, dc, ic )                             
  294.                                                                        
  295.         (   dafus_c ( CONST_VEC(sum), (nd), (ni), (dc), (ic) )   )
  296.    #define  dasac_c( handle, n, buflen, buffer )                       
  297.                                                                        
  298.         (   dasac_c ( (handle), (n), (buflen), CONST_VOID(buffer) )   )
  299.                       
  300.    #define  det_c( m1 )                                                
  301.                                                                        
  302.         (   det_c ( CONST_MAT(m1) )   )
  303.    #define  diags2_c( symmat, diag, rotate )                           
  304.                                                                        
  305.         (   diags2_c ( CONST_MAT2(symmat), (diag), (rotate) )   )       
  306.                 
  307.                                                 
  308.    #define  dvdot_c( s1, s2 )                                         
  309.                                                                       
  310.            ( dvdot_c ( CONST_VEC(s1), CONST_VEC(s2) )   )
  311.    
  312.    
  313.    #define  dvhat_c( v1, v2 )                                         
  314.                                                                       
  315.            ( dvhat_c ( CONST_VEC(v1), (v2) )   )
  316.    #define  edlimb_c( a, b, c, viewpt, limb )                          
  317.                                                                        
  318.         (   edlimb_c( (a), (b), (c), CONST_VEC(viewpt), (limb) )   )
  319.    #define  ekacec_c( handle, segno,  recno, column, nvals, vallen,    
  320.                       cvals,  isnull                               )   
  321.                                                                        
  322.         (   ekacec_c( (handle), (segno), (recno), CONST_STR(column),   
  323.                       (nvals),  (vallen), CONST_VOID(cvals),           
  324.                       (isnull)                                      )  ) 
  325.    #define  ekaced_c( handle, segno,  recno, column, nvals,            
  326.                       dvals,  isnull                               )   
  327.                                                                        
  328.         (   ekaced_c( (handle), (segno), (recno), CONST_STR(column),   
  329.                       (nvals),  CONST_VEC(dvals), (isnull)          )  ) 
  330.    #define  ekacei_c( handle, segno,  recno, column, nvals,            
  331.                       ivals,  isnull                               )   
  332.                                                                        
  333.         (   ekacei_c( (handle), (segno), (recno), CONST_STR(column),   
  334.                       (nvals),  CONST_IVEC(ivals), (isnull)         )  ) 
  335.    #define  ekaclc_c( handle, segno,  column, vallen, cvals, entszs,   
  336.                       nlflgs, rcptrs, wkindx                         ) 
  337.                                                                        
  338.         (   ekaclc_c( (handle), (segno),  (column),  (vallen),         
  339.                       CONST_VOID(cvals),  CONST_IVEC(entszs),          
  340.                       CONST_BOOL(nlflgs), CONST_IVEC(rcptrs),          
  341.                       (wkindx)                                      )  ) 
  342.    #define  ekacld_c( handle, segno,  column, dvals, entszs, nlflgs,   
  343.                       rcptrs, wkindx                                 ) 
  344.                                                                        
  345.         (   ekacld_c( (handle),           (segno),           (column), 
  346.                       CONST_VEC(dvals),   CONST_IVEC(entszs),          
  347.                       CONST_BOOL(nlflgs), CONST_IVEC(rcptrs),          
  348.                       (wkindx)                                      )  ) 
  349.    #define  ekacli_c( handle, segno,  column, ivals, entszs, nlflgs,   
  350.                       rcptrs, wkindx                                 ) 
  351.                                                                        
  352.         (   ekacli_c( (handle),           (segno),           (column), 
  353.                       CONST_IVEC(ivals),  CONST_IVEC(entszs),          
  354.                       CONST_BOOL(nlflgs), CONST_IVEC(rcptrs),          
  355.                       (wkindx)                                      )  ) 
  356.    #define  ekbseg_c( handle, tabnam, ncols, cnmlen, cnames, declen,   
  357.                       decls,  segno                                 )  
  358.                                                                        
  359.         (   ekbseg_c( (handle), (tabnam), (ncols), (cnmlen),           
  360.                       CONST_VOID(cnames), (declen),                    
  361.                       CONST_VOID(decls),  (segno)             )  )    
  362.    #define  ekifld_c( handle, tabnam, ncols, nrows, cnmlen, cnames,    
  363.                       declen, decls,  segno, rcptrs                 )  
  364.                                                                        
  365.         (   ekifld_c( (handle), (tabnam), (ncols), (nrows), (cnmlen),  
  366.                       CONST_VOID(cnames), (declen),                    
  367.                       CONST_VOID(decls),  (segno), (rcptrs)         )  )    
  368.    #define  ekucec_c( handle, segno,  recno, column, nvals, vallen,    
  369.                       cvals,  isnull                               )   
  370.                                                                        
  371.         (   ekucec_c( (handle), (segno), (recno), CONST_STR(column),   
  372.                       (nvals),  (vallen), CONST_VOID(cvals),           
  373.                       (isnull)                                      )  ) 
  374.    #define  ekuced_c( handle, segno,  recno, column, nvals,            
  375.                       dvals,  isnull                               )   
  376.                                                                        
  377.         (   ekuced_c( (handle), (segno), (recno),   CONST_STR(column), 
  378.                       (nvals),  CONST_VOID(dvals), (isnull)         )  ) 
  379.    #define  ekucei_c( handle, segno,  recno, column, nvals,            
  380.                       ivals,  isnull                               )   
  381.                                                                        
  382.         (   ekucei_c( (handle), (segno), (recno),   CONST_STR(column), 
  383.                       (nvals),  CONST_VOID(ivals), (isnull)         )  ) 
  384.    #define  el2cgv_c( ellipse, center, smajor, sminor )                
  385.                                                                        
  386.         (   el2cgv_c( CONST_ELLIPSE(ellipse), (center),                
  387.                       (smajor),               (sminor)  )   )
  388.    #define  esrchc_c( value, ndim, lenvals, array )                    
  389.                                                                        
  390.         (   esrchc_c ( CONST_STR(value),  (ndim),  (lenvals),          
  391.                        CONST_VOID(array)                      ) )
  392.    #define  eul2xf_c( eulang, axisa, axisb, axisc, xform )             
  393.                                                                        
  394.         (   eul2xf_c ( CONST_VEC(eulang), (axisa), (axisb), (axisc),   
  395.                        (xform)                                     )  )
  396.    
  397.    
  398.    #define  getelm_c( frstyr, lineln, lines, epoch, elems )            
  399.                                                                        
  400.         (   getelm_c ( (frstyr), (lineln), CONST_VOID(lines),          
  401.                        (epoch),  (elems)                      )   )   
  402.    #define  illum_c( target, et,    abcorr, obsrvr,                    
  403.                      spoint, phase, solar,  emissn )                   
  404.                                                                        
  405.         (   illum_c ( (target),          (et),    (abcorr), (obsrvr),  
  406.                       CONST_VEC(spoint), (phase), (solar),  (emissn) )  )
  407.    
  408.    #define  inedpl_c( a, b, c, plane, ellipse, found )                 
  409.                                                                        
  410.         (   inedpl_c ( (a),                (b),         (c),           
  411.                        CONST_PLANE(plane), (ellipse),   (found) )   )
  412.    #define  inrypl_c( vertex, dir, plane, nxpts, xpt )                 
  413.                                                                        
  414.         (   inrypl_c ( CONST_VEC(vertex),   CONST_VEC(dir),            
  415.                        CONST_PLANE(plane),  (nxpts),        (xpt) )   )
  416.    
  417.    #define  invert_c( m1, m2 )                                         
  418.                                                                        
  419.         (   invert_c ( CONST_MAT(m1), (m2) )   )
  420.    #define  invort_c( m, mit )                                         
  421.                                                                        
  422.         (   invort_c ( CONST_MAT(m), (mit) )   )
  423.    #define  isordv_c( array, n )                                       
  424.                                                                        
  425.         (   isordv_c ( CONST_IVEC(array), (n) )  )
  426.    #define  isrchc_c( value, ndim, lenvals, array )                    
  427.                                                                        
  428.         (   isrchc_c ( CONST_STR(value),  (ndim),  (lenvals),          
  429.                        CONST_VOID(array)                      ) )
  430.    #define  isrchd_c( value, ndim, array )                             
  431.                                                                        
  432.         (   isrchd_c( (value),  (ndim),  CONST_VEC(array) )  )
  433.    #define  isrchi_c( value, ndim, array )                             
  434.                                                                        
  435.         (   isrchi_c( (value),  (ndim),  CONST_IVEC(array) )  )
  436.    #define  isrot_c( m, ntol, dtol )                                   
  437.                                                                        
  438.         (   isrot_c ( CONST_MAT(m), (ntol), (dtol) )   )
  439.         
  440.         
  441.    #define  lmpool_c( cvals, lenvals, n )                              
  442.                                                                        
  443.         (   lmpool_c( CONST_VOID(cvals), (lenvals), (n) )  )
  444.    #define  lstltc_c( value, ndim, lenvals, array )                    
  445.                                                                        
  446.         (   lstltc_c ( CONST_STR(value),  (ndim),  (lenvals),          
  447.                        CONST_VOID(array)                      ) )
  448.    #define  lstled_c( value, ndim, array )                             
  449.                                                                        
  450.         (   lstled_c( (value),  (ndim),  CONST_VEC(array) )  )
  451.    #define  lstlei_c( value, ndim, array )                             
  452.                                                                        
  453.         (   lstlei_c( (value),  (ndim),  CONST_IVEC(array) )  )
  454.    #define  lstlec_c( value, ndim, lenvals, array )                    
  455.                                                                        
  456.         (   lstlec_c ( CONST_STR(value),  (ndim),  (lenvals),          
  457.                        CONST_VOID(array)                      ) )
  458.    #define  lstltd_c( value, ndim, array )                             
  459.                                                                        
  460.         (   lstltd_c( (value),  (ndim),  CONST_VEC(array) )  )
  461.    #define  lstlti_c( value, ndim, array )                             
  462.                                                                        
  463.         (   lstlti_c( (value),  (ndim),  CONST_IVEC(array) )  )
  464.    #define  m2eul_c( r, axis3,  axis2,  axis1,                         
  465.                         angle3, angle2, angle1 )                       
  466.                                                                        
  467.         (   m2eul_c ( CONST_MAT(r), (axis3),  (axis2),  (axis1),       
  468.                                     (angle3), (angle2), (angle1) )   ) 
  469.                                                                        
  470.    #define  m2q_c( r, q )                                              
  471.                                                                        
  472.         (   m2q_c ( CONST_MAT(r), (q) )   )
  473.         
  474.         
  475.    #define  mequ_c( m1, m2 )                                           
  476.                                                                        
  477.            ( mequ_c  ( CONST_MAT(m1), m2 ) )
  478.    
  479.    #define  mequg_c( m1, nr, nc, mout )                                
  480.                                                                        
  481.         (   mequg_c  ( CONST_MAT(m1), (nr), (nc), mout )   )
  482.    
  483.    #define  mtxm_c( m1, m2, mout )                                     
  484.                                                                        
  485.         (   mtxm_c ( CONST_MAT(m1), CONST_MAT(m2), (mout) )   )
  486.    #define  mtxmg_c( m1, m2, ncol1, nr1r2, ncol2, mout )               
  487.                                                                        
  488.         (   mtxmg_c ( CONST_MAT(m1), CONST_MAT(m2),                    
  489.                       (ncol1),       (nr1r2),       (ncol2), (mout) )  )
  490.    #define  mtxv_c( m1, vin, vout )                                    
  491.                                                                        
  492.         (   mtxv_c ( CONST_MAT(m1), CONST_VEC(vin), (vout) )   )
  493.    #define  mtxvg_c( m1, v2, nrow1, nc1r2, vout )                      
  494.                                                                        
  495.         (   mtxvg_c( CONST_VOID(m1), CONST_VOID(v2),                   
  496.                     (nrow1),        (nc1r2),       (vout) )   )
  497.    #define  mxm_c( m1, m2, mout )                                      
  498.                                                                        
  499.         (   mxm_c ( CONST_MAT(m1), CONST_MAT(m2), (mout) )   )
  500.    #define  mxmg_c( m1, m2, row1, col1, col2, mout )                   
  501.                                                                        
  502.         (   mxmg_c ( CONST_VOID(m1), CONST_VOID(m2),                   
  503.                      (row1), (col1), (col2), (mout) )   )
  504.    #define  mxmt_c( m1, m2, mout )                                     
  505.                                                                        
  506.         (   mxmt_c ( CONST_MAT(m1), CONST_MAT(m2), (mout) )   )
  507.    #define  mxmtg_c( m1, m2, nrow1, nc1c2, nrow2, mout )               
  508.                                                                        
  509.         (   mxmtg_c ( CONST_VOID(m1), CONST_VOID(m2),                  
  510.                       (nrow1),        (nc1c2),                         
  511.                       (nrow2),        (mout)             )   )
  512.    #define  mxv_c( m1, vin, vout )                                     
  513.                                                                        
  514.         (   mxv_c ( CONST_MAT(m1), CONST_VEC(vin), (vout) )   )
  515.    #define  mxvg_c( m1, v2, nrow1, nc1r2, vout )                       
  516.                                                                        
  517.         (   mxvg_c( CONST_VOID(m1), CONST_VOID(v2),                    
  518.                     (nrow1),        (nc1r2),       (vout) )   )
  519.    #define  nearpt_c( positn, a, b, c, npoint, alt )                   
  520.                                                                        
  521.         (   nearpt_c ( CONST_VEC(positn), (a),  (b),  (c),             
  522.                        (npoint),          (alt)            )   )
  523.    #define  npedln_c( a, b, c, linept, linedr, pnear, dist )           
  524.                                                                        
  525.         (   npedln_c ( (a),               (b),               (c),      
  526.                        CONST_VEC(linept), CONST_VEC(linedr),           
  527.                        (pnear),           (dist)                 )   )
  528.    #define  nplnpt_c( linpt, lindir, point, pnear, dist )              
  529.                                                                        
  530.         (   nplnpt_c ( CONST_VEC(linpt), CONST_VEC(lindir),            
  531.                        CONST_VEC(point), (pnear), (dist )   )   )
  532.         
  533.         
  534.    #define  nvc2pl_c( normal, constant, plane )                        
  535.                                                                        
  536.         (   nvc2pl_c ( CONST_VEC(normal), (constant), (plane) )  )
  537.    #define  nvp2pl_c( normal, point, plane )                           
  538.                                                                        
  539.         (   nvp2pl_c( CONST_VEC(normal), CONST_VEC(point), (plane) )  )
  540.    #define  orderc_c( lenvals, array, ndim, iorder )                   
  541.                                                                        
  542.         (   orderc_c ( (lenvals), CONST_VOID(array), (ndim), (iorder)) )
  543.    #define  orderd_c( array, ndim, iorder )                            
  544.                                                                        
  545.         (   orderd_c ( CONST_VEC(array), (ndim), (iorder) )  )
  546.    #define  orderi_c( array, ndim, iorder )                            
  547.                                                                        
  548.         (   orderi_c ( CONST_IVEC(array), (ndim), (iorder) )  )
  549.    #define  oscelt_c( state, et, mu, elts )                            
  550.                                                                        
  551.         (   oscelt_c ( CONST_VEC(state), (et), (mu), (elts)  )   )
  552.    #define  pcpool_c( name, n, lenvals, cvals )                        
  553.                                                                        
  554.         (   pcpool_c ( (name), (n), (lenvals), CONST_VOID(cvals) )  )
  555.    #define  pdpool_c( name, n, dvals )                                 
  556.                                                                        
  557.         (   pdpool_c ( (name), (n), CONST_VEC(dvals) )  )
  558.    #define  pipool_c( name, n, ivals )                                 
  559.                                                                        
  560.         (   pipool_c ( (name), (n), CONST_IVEC(ivals) )  )
  561.    #define  pl2nvc_c( plane, normal, constant )                        
  562.                                                                        
  563.         (   pl2nvc_c ( CONST_PLANE(plane),  (normal), (constant) )  )
  564.    #define  pl2nvp_c( plane, normal, point )                           
  565.                                                                        
  566.         (   pl2nvp_c ( CONST_PLANE(plane),  (normal), (point) )  )
  567.    #define  pl2psv_c( plane, point, span1, span2 )                     
  568.                                                                        
  569.         (   pl2psv_c( CONST_PLANE(plane), (point), (span1), (span2) )  )
  570.    #define  prop2b_c( gm, pvinit, dt, pvprop )                         
  571.                                                                        
  572.         (   prop2b_c ( (gm),  CONST_VEC(pvinit), (dt), (pvprop)  )   )
  573.    #define  psv2pl_c( point, span1, span2, plane )                     
  574.                                                                        
  575.         (   psv2pl_c ( CONST_VEC(point),  CONST_VEC(span1),            
  576.                        CONST_VEC(span2),  (plane)           )   )
  577.    #define  qdq2av_c( q, dq, av )                                      
  578.                                                                        
  579.         (   qdq2av_c ( CONST_VEC(q), CONST_VEC(dq),  (av) )    )
  580.    #define  q2m_c( q, r )                                              
  581.                                                                        
  582.         (   q2m_c ( CONST_VEC(q), (r) )    )
  583.    #define  qxq_c( q1, q2, qout )                                      
  584.                                                                        
  585.         (   qxq_c ( CONST_VEC(q1), CONST_VEC(q2),  (qout) )    )
  586.    #define  rav2xf_c( rot, av, xform )                                 
  587.                                                                        
  588.         (   rav2xf_c ( CONST_MAT(rot), CONST_VEC(av), (xform) )   )
  589.    
  590.    
  591.    #define  raxisa_c( matrix, axis, angle )                            
  592.                                                                        
  593.         (   raxisa_c ( CONST_MAT(matrix), (axis), (angle) )   );            
  594.                                 
  595.    #define  reccyl_c( rectan, r, lon, z )                              
  596.                                                                        
  597.         (   reccyl_c ( CONST_VEC(rectan), (r), (lon), (z)  )   )
  598.    #define  recgeo_c( rectan, re, f, lon, lat, alt )                   
  599.                                                                        
  600.         (   recgeo_c ( CONST_VEC(rectan), (re),   (f),                 
  601.                        (lon),             (lat),  (alt) )   )
  602.    #define  reclat_c( rectan, r, lon, lat )                            
  603.                                                                        
  604.         (   reclat_c ( CONST_VEC(rectan), (r), (lon), (lat)  )   )
  605.    #define  recrad_c( rectan, radius, ra, dec )                        
  606.                                                                        
  607.         (   recrad_c ( CONST_VEC(rectan), (radius), (ra), (dec)  )   )
  608.    #define  recsph_c( rectan, r, colat, lon )                          
  609.                                                                        
  610.         (   recsph_c ( CONST_VEC(rectan), (r), (colat), (lon)  )   )
  611.    #define  reordd_c( iorder, ndim, array )                            
  612.                                                                        
  613.         (   reordd_c ( CONST_IVEC(iorder), (ndim), (array) )  )
  614.    #define  reordi_c( iorder, ndim, array )                            
  615.                                                                        
  616.         (   reordi_c ( CONST_IVEC(iorder), (ndim), (array) )  )
  617.    #define  reordl_c( iorder, ndim, array )                            
  618.                                                                        
  619.         (   reordl_c ( CONST_IVEC(iorder), (ndim), (array) )  )
  620.    #define  rotmat_c( m1, angle, iaxis, mout  )                        
  621.                                                                        
  622.         (   rotmat_c ( CONST_MAT(m1), (angle), (iaxis), (mout)  )   )
  623.    #define  rotvec_c( v1, angle, iaxis, vout )                         
  624.                                                                        
  625.         (   rotvec_c ( CONST_VEC(v1), (angle), (iaxis), (vout)  )   )
  626.    #define  saelgv_c( vec1, vec2, smajor, sminor )                     
  627.                                                                        
  628.         (   saelgv_c ( CONST_VEC(vec1),  CONST_VEC(vec2),              
  629.                        (smajor),         (sminor)         )   )
  630.    #define  spk14a_c( handle, ncsets, coeffs, epochs )                 
  631.                                                                        
  632.         (   spk14a_c ( (handle),           (ncsets),                   
  633.                        CONST_VEC(coeffs),  CONST_VEC(epochs) )  ) 
  634.    
  635.    
  636.    #define  spkapo_c( targ, et, ref, sobs, abcorr, ptarg, lt )         
  637.                                                                        
  638.         (   spkapo_c ( (targ),   (et),    (ref), CONST_VEC(sobs),      
  639.                        (abcorr), (ptarg), (lt)                   )  )
  640.    #define  spkapp_c( targ, et, ref, sobs, abcorr, starg, lt )         
  641.                                                                        
  642.         (   spkapp_c ( (targ),   (et),    (ref), CONST_VEC(sobs),      
  643.                        (abcorr), (starg), (lt)                   )  )
  644.    #define  spkuds_c( descr, body, center, frame, type,                
  645.                       first, last, begin,  end         )               
  646.                                                                        
  647.         (   spkuds_c ( CONST_VEC(descr), (body), (center), (frame),    
  648.                        (type),  (first), (last), (begin),  (end)    )  )
  649.    #define  spkw02_c( handle, body,   center, frame,  first,  last,    
  650.                       segid,  intlen, n,      polydg, cdata,  btime )  
  651.                                                                        
  652.         (   spkw02_c ( (handle), (body),   (center),         (frame),  
  653.                        (first),  (last),   (segid),          (intlen), 
  654.                        (n),      (polydg), CONST_VEC(cdata), (btime) ) )
  655.    #define  spkw03_c( handle, body,   center, frame,  first,  last,    
  656.                       segid,  intlen, n,      polydg, cdata,  btime )  
  657.                                                                        
  658.         (   spkw03_c ( (handle), (body),   (center),         (frame),  
  659.                        (first),  (last),   (segid),          (intlen), 
  660.                        (n),      (polydg), CONST_VEC(cdata), (btime) ) )
  661.    #define  spkw05_c( handle, body,   center, frame,  first,  last,    
  662.                       segid,  gm,     n,      states, epochs        )  
  663.                                                                        
  664.         (   spkw05_c ( (handle),  (body),   (center),   (frame),       
  665.                        (first),   (last),   (segid),    (gm),          
  666.                        (n),                                            
  667.                        CONST_MAT6(states),  CONST_VEC(epochs)    )   )
  668.    #define  spkw08_c( handle, body,   center, frame,  first,  last,    
  669.                       segid,  degree, n,      states, epoch1, step )   
  670.                                                                        
  671.         (   spkw08_c ( (handle),  (body),   (center),   (frame),       
  672.                        (first),   (last),   (segid),    (degree),      
  673.                        (n),       CONST_MAT6(states),   (epoch1),      
  674.                        (step)                                     )   )
  675.    #define  spkw09_c( handle, body,   center, frame,  first,  last,    
  676.                       segid,  degree, n,      states, epochs       )   
  677.                                                                        
  678.         (   spkw09_c ( (handle), (body),   (center), (frame),          
  679.                        (first),  (last),   (segid),  (degree),  (n),   
  680.                        CONST_MAT6(states), CONST_VEC(epochs)        )  )
  681.    #define  spkw10_c( handle, body,   center, frame,  first,  last,    
  682.                       segid,  consts, n,      elems,  epochs       )   
  683.                                                                        
  684.         (   spkw10_c ( (handle), (body),  (center), (frame),           
  685.                        (first),  (last),  (segid),  CONST_VEC(consts), 
  686.                        (n),      CONST_VEC(elems),  CONST_VEC(epochs)) )
  687.    #define  spkw12_c( handle, body,   center, frame,  first,  last,    
  688.                       segid,  degree, n,      states, epoch0, step )   
  689.                                                                        
  690.         (   spkw12_c ( (handle),  (body),   (center),   (frame),       
  691.                        (first),   (last),   (segid),    (degree),      
  692.                        (n),       CONST_MAT6(states),   (epoch0),      
  693.                        (step)                                     )   )
  694.    #define  spkw13_c( handle, body,   center, frame,  first,  last,    
  695.                       segid,  degree, n,      states, epochs       )   
  696.                                                                        
  697.         (   spkw13_c ( (handle), (body),   (center), (frame),          
  698.                        (first),  (last),   (segid),  (degree),  (n),   
  699.                        CONST_MAT6(states), CONST_VEC(epochs)        )  )
  700.    #define  spkw15_c( handle, body,   center, frame,  first,  last,    
  701.                       segid,  epoch,  tp,     pa,     p,      ecc,     
  702.                       j2flg,  pv,     gm,     j2,     radius         ) 
  703.                                                                        
  704.         (   spkw15_c ( (handle), (body),  (center), (frame),           
  705.                        (first),  (last),  (segid),  (epoch),           
  706.                        CONST_VEC(tp),     CONST_VEC(pa),               
  707.                        (p),      (ecc),   (j2flg),  CONST_VEC(pv),     
  708.                        (gm),     (j2),    (radius)                )   )
  709.    #define  spkw17_c( handle, body,   center, frame,  first,  last,    
  710.                       segid,  epoch,  eqel,   rapol,  decpol       )   
  711.                                                                        
  712.         (   spkw17_c ( (handle), (body),  (center), (frame),           
  713.                        (first),  (last),  (segid),  (epoch),           
  714.                        CONST_VEC(eqel),   (rapol),  (decpol)  )   )
  715.    #define  spkw18_c( handle, subtyp, body,   center, frame,  first,   
  716.                       last,   segid,  degree, n,      packts, epochs ) 
  717.                                                                        
  718.         (   spkw18_c ( (handle), (subtyp), (body),  (center), (frame), 
  719.                        (first),  (last),   (segid), (degree), (n),     
  720.                        CONST_VOID(packts), CONST_VEC(epochs)        )  )
  721.    #define  srfxpt_c( method, target, et,    abcorr, obsrvr, dref,     
  722.                       dvec,   spoint, dist,  trgepc, obspos, found )   
  723.                                                                        
  724.         (   srfxpt_c ( (method), (target),  (et), (abcorr), (obsrvr),  
  725.                        (dref),   CONST_VEC(dvec), (spoint), (dist),    
  726.                        (trgepc), (obspos),        (found)          )   )
  727.    #define  stelab_c( pobj, vobj, appobj )                             
  728.                                                                        
  729.         (   stelab_c ( CONST_VEC(pobj), CONST_VEC(vobj), (appobj)  )   )
  730.    #define  sumad_c( array, n )                                        
  731.                                                                        
  732.         (   sumad_c ( CONST_VEC(array), (n)  )   )
  733.    #define  sumai_c( array, n )                                        
  734.                                                                        
  735.         (   sumai_c ( CONST_IVEC(array), (n)  )   )
  736.    #define  surfnm_c( a, b, c, point, normal )                         
  737.                                                                        
  738.         (   surfnm_c ( (a), (b), (c), CONST_VEC(point), (normal) )   )
  739.    #define  surfpt_c( positn, u, a, b, c, point, found )               
  740.                                                                        
  741.         (   surfpt_c ( CONST_VEC(positn), CONST_VEC(u),                
  742.                        (a),               (b),               (c),      
  743.                        (point),           (found)                 )   )
  744.    #define  swpool_c( agent, nnames, lenvals, names )                  
  745.                                                                        
  746.         (   swpool_c( CONST_STR(agent), (nnames),                      
  747.                       (lenvals),        CONST_VOID(names)         )    )
  748.    #define  trace_c( m1 )                                              
  749.                                                                        
  750.            ( trace_c ( CONST_MAT(m1) ) )
  751.    #define  twovec_c( axdef, indexa, plndef, indexp, mout )            
  752.                                                                        
  753.         (   twovec_c ( CONST_VEC(axdef),  (indexa),                    
  754.                        CONST_VEC(plndef), (indexp), (mout) )   )
  755.    #define  ucrss_c( v1, v2, vout )                                    
  756.                                                                        
  757.         (   ucrss_c ( CONST_VEC(v1), CONST_VEC(v2), (vout) )   )
  758.    #define  unorm_c( v1, vout, vmag )                                  
  759.                                                                        
  760.         (   unorm_c ( CONST_VEC(v1), (vout), (vmag) )   )
  761.    #define  unormg_c( v1, ndim, vout, vmag )                           
  762.                                                                        
  763.         (   unormg_c ( CONST_VEC(v1), (ndim), (vout), (vmag) )   )
  764.    #define  vadd_c( v1, v2, vout )                                     
  765.                                                                        
  766.         (   vadd_c ( CONST_VEC(v1), CONST_VEC(v2), (vout) )   )
  767.    #define  vaddg_c( v1, v2, ndim,vout )                               
  768.                                                                        
  769.         (  vaddg_c ( CONST_VEC(v1), CONST_VEC(v2), (ndim), (vout) ) )
  770.    
  771.    #define  vcrss_c( v1, v2, vout )                                    
  772.                                                                        
  773.         (   vcrss_c ( CONST_VEC(v1), CONST_VEC(v2), (vout) )   )
  774.    #define  vdist_c( v1, v2 )                                          
  775.                                                                        
  776.         (   vdist_c ( CONST_VEC(v1), CONST_VEC(v2) )   )
  777.    #define  vdistg_c( v1, v2, ndim )                                   
  778.                                                                        
  779.         (   vdistg_c ( CONST_VEC(v1), CONST_VEC(v2), (ndim) )   )
  780.    #define  vdot_c( v1, v2 )                                           
  781.                                                                        
  782.         (   vdot_c ( CONST_VEC(v1), CONST_VEC(v2) )   )
  783.    #define  vdotg_c( v1, v2, ndim )                                    
  784.                                                                        
  785.         (   vdotg_c ( CONST_VEC(v1), CONST_VEC(v2), (ndim) )   )
  786.    #define  vequ_c( vin, vout )                                        
  787.                                                                        
  788.         (   vequ_c ( CONST_VEC(vin), (vout) )   )
  789.    #define  vequg_c( vin, ndim, vout )                                 
  790.                                                                        
  791.         (   vequg_c ( CONST_VEC(vin), (ndim), (vout) )   )
  792.    #define  vhat_c( v1, vout )                                         
  793.                                                                        
  794.         (   vhat_c ( CONST_VEC(v1), (vout) )   )
  795.    #define  vhatg_c( v1, ndim, vout )                                  
  796.                                                                        
  797.         (   vhatg_c ( CONST_VEC(v1), (ndim), (vout) )   )
  798.    #define  vlcom3_c( a, v1, b, v2, c, v3, sum )                       
  799.                                                                        
  800.         (   vlcom3_c ( (a), CONST_VEC(v1),                             
  801.                        (b), CONST_VEC(v2),                             
  802.                        (c), CONST_VEC(v3), (sum) )   )
  803.    #define  vlcom_c( a, v1, b, v2, sum )                               
  804.                                                                        
  805.         (   vlcom_c ( (a), CONST_VEC(v1),                              
  806.                       (b), CONST_VEC(v2), (sum) )   )
  807.    #define  vlcomg_c( n, a, v1, b, v2, sum )                           
  808.                                                                        
  809.            ( vlcomg_c ( (n), (a), CONST_VEC(v1),                       
  810.                              (b), CONST_VEC(v2),  (sum) )   )
  811.    #define  vminug_c( v1, ndim, vout )                                 
  812.                                                                        
  813.        (   vminug_c ( CONST_VEC(v1), (ndim), (vout) )   )
  814.            
  815.            
  816.    #define  vminus_c( v1, vout )                                       
  817.                                                                        
  818.         (   vminus_c ( CONST_VEC(v1), (vout) )   )
  819.    #define  vnorm_c( v1 )                                              
  820.                                                                        
  821.         (   vnorm_c ( CONST_VEC(v1) )   )
  822.    #define  vnormg_c( v1, ndim )                                       
  823.                                                                        
  824.         (   vnormg_c ( CONST_VEC(v1), (ndim) )   )
  825.    #define  vperp_c( a, b, p )                                         
  826.                                                                        
  827.         (   vperp_c ( CONST_VEC(a), CONST_VEC(b), (p) )   )
  828.    #define  vprjp_c( vin, plane, vout )                                
  829.                                                                        
  830.         (   vprjp_c ( CONST_VEC(vin), CONST_PLANE(plane), (vout) )   )
  831.    #define  vprjpi_c( vin, projpl, invpl, vout, found )                
  832.                                                                        
  833.         (   vprjpi_c( CONST_VEC(vin),     CONST_PLANE(projpl),         
  834.                       CONST_PLANE(invpl), (vout),           (found) ) )
  835.    #define  vproj_c( a, b, p )                                         
  836.                                                                        
  837.         (   vproj_c ( CONST_VEC(a), CONST_VEC(b), (p) )   )
  838.    #define  vrel_c( v1, v2 )                                           
  839.                                                                        
  840.            ( vrel_c ( CONST_VEC(v1), CONST_VEC(v2) )   )
  841.    
  842.     
  843.    #define  vrelg_c( v1, v2, ndim )                                    
  844.                                                                        
  845.            ( vrelg_c ( CONST_VEC(v1), CONST_VEC(v2), (ndim) )   )
  846.    #define  vrotv_c( v, axis, theta, r )                               
  847.                                                                        
  848.         (   vrotv_c ( CONST_VEC(v), CONST_VEC(axis), (theta), (r) )   )
  849.    #define  vscl_c( s, v1, vout )                                      
  850.                                                                        
  851.         (   vscl_c ( (s), CONST_VEC(v1), (vout) )   )
  852.    #define  vsclg_c( s, v1, ndim, vout )                               
  853.                                                                        
  854.         (   vsclg_c ( (s), CONST_VEC(v1), (ndim), (vout) )   )
  855.    #define  vsep_c( v1, v2 )                                           
  856.                                                                        
  857.         (   vsep_c ( CONST_VEC(v1), CONST_VEC(v2) )   )
  858.    #define  vsepg_c( v1, v2, ndim)                                     
  859.                                                                        
  860.            ( vsepg_c ( CONST_VEC(v1), CONST_VEC(v2), ndim )  )
  861.    
  862.    
  863.    #define  vsub_c( v1, v2, vout )                                     
  864.                                                                        
  865.         (   vsub_c ( CONST_VEC(v1), CONST_VEC(v2), (vout) )   )
  866.    #define  vsubg_c( v1, v2, ndim, vout )                              
  867.                                                                        
  868.         (   vsubg_c ( CONST_VEC(v1), CONST_VEC(v2),                    
  869.                       (ndim),        (vout)            )   )
  870.    #define  vtmv_c( v1, mat, v2 )                                      
  871.                                                                        
  872.         ( vtmv_c ( CONST_VEC(v1), CONST_MAT(mat), CONST_VEC(v2) ) )
  873.    
  874.    
  875.    #define  vtmvg_c( v1, mat, v2, nrow, ncol )                         
  876.                                                                        
  877.         ( vtmvg_c ( CONST_VOID(v1), CONST_VOID(mat), CONST_VOID(v2),   
  878.                    (nrow), (ncol)                                   )  )
  879.    #define  vupack_c( v, x, y, z )                                     
  880.                                                                        
  881.         (   vupack_c ( CONST_VEC(v), (x), (y), (z) )   )
  882.    #define  vzero_c( v1 )                                              
  883.                                                                        
  884.         (   vzero_c ( CONST_VEC(v1) )   )
  885.    #define  vzerog_c( v1, ndim )                                       
  886.                                                                        
  887.            (   vzerog_c ( CONST_VEC(v1), (ndim) )   )
  888.    #define  xf2eul_c( xform, axisa, axisb, axisc, eulang, unique )     
  889.                                                                        
  890.         (   xf2eul_c( CONST_MAT6(xform), (axisa), (axisb), (axisc),    
  891.                       (eulang),          (unique)                  )  )  
  892.    #define  xf2rav_c( xform, rot, av )                                 
  893.                                                                        
  894.         (   xf2rav_c( CONST_MAT6(xform), (rot), (av) )   )  
  895.    #define  xpose6_c( m1, mout )                                       
  896.                                                                        
  897.         (   xpose6_c ( CONST_MAT6(m1), (mout) )   )
  898.    #define  xpose_c( m1, mout )                                        
  899.                                                                        
  900.         (   xpose_c ( CONST_MAT(m1), (mout) )   )
  901.    #define  xposeg_c( matrix, nrow, ncol, mout )                       
  902.                                                                        
  903.         (   xposeg_c ( CONST_VOID(matrix), (nrow), (ncol), (mout) )   )
  904. #endif