#ifndef SLAAINCLD
#define SLAAINCLD
    
#include<string>
#include<iostream>
#include<sstream>
using std::string;
using std::ostream;
using std::endl;
 
    extern"C" { void sla_pv2el_ ( const double[6],const double*,const double*,int*,double*,double*,double*,double*,double*,double*,double*,double*,double*,int*); }
extern"C" { void sla_geoc_ ( const double*,const double*,double*,double*); }
extern"C" { float sla_sep_ ( const float*,const float*,const float*,const float*); }
extern"C" { void sla_ampqk_ ( const double*,const double*,const double[21],double*,double*); }
extern"C" { void sla_aoppat_ ( const double*,double[14]); }
extern"C" { double sla_epb2d_ ( const double*); }
extern"C" { void sla_dafin_ ( const char*,const int*,int*,double*,int*); }
extern"C" { void sla_ecmat_ ( const double*,double[3][3]); }
extern"C" { void sla_amp_ ( const double*,const double*,const double*,const double*,double*,double*); }
extern"C" { void sla_tp2v_ ( const float*,const float*,const float[3],float[3]); }
extern"C" { void sla_refz_ ( const double*,const double*,const double*,double*); }
extern"C" { void sla_caldj_ ( const int*,const int*,const int*,double*,int*); }
extern"C" { double sla_gmst_ ( const double*); }
extern"C" { void sla_calyd_ ( const int*,const int*,const int*,int*,int*,int*); }
extern"C" { float sla_rvgalc_ ( const float*,const float*); }
extern"C" { void sla_mxv_ ( const float[3][3],const float[3],float[3]); }
extern"C" { void sla_epv_ ( const double*,double[3],double[3],double[3],double[3]); }
extern"C" { double sla_dranrm_ ( const double*); }
extern"C" { void sla_dtf2d_ ( const int*,const int*,const double*,double*,int*); }
extern"C" { void sla_galsup_ ( const double*,const double*,double*,double*); }
extern"C" { void sla_preces_ ( const char*,const double*,const double*,double*,double*); }
extern"C" { void sla_euler_ ( const char*,const int*,const float*,const float*,const float*,float[3][3]); }
extern"C" { void sla_nutc_ ( const double*,double*,double*,double*); }
extern"C" { void sla_refco_ ( const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,double*,double*); }
extern"C" { float sla_range_ ( const double*); }
extern"C" { void sla_dvn_ ( const double[3],double[3],double*); }
extern"C" { void sla_pertel_ ( const int*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,double*,double*,double*,double*,double*,double*,double*,int*); }
extern"C" { void sla_mapqkz_ ( const double*,const double*,const double[21],double*,double*); }
extern"C" { void sla_map_ ( const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,double*,double*); }
extern"C" { void sla_aoppa_ ( const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,double[14]); }
extern"C" { void sla_polmo_ ( const double*,const double*,double*,const double*,double*,double*,double*); }
extern"C" { void sla_dmxv_ ( const double[3][3],const double[3],double[3]); }
extern"C" { void sla_deuler_ ( const char*,const int*,const double*,const double*,const double*,double[3][3]); }
extern"C" { void sla_cs2c_ ( const float*,const float*,float[3]); }
extern"C" { void sla_imxv_ ( const float[3][3],const float[3],float[3]); }
extern"C" { void sla_fk5hz_ ( const double*,const double*,const double*,double*,double*); }
extern"C" { float sla_vdv_ ( const float[3],const float[3]); }
extern"C" { void sla_dcc2s_ ( const double[3],double*,double*); }
extern"C" { void sla_refro_ ( const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,double*); }
extern"C" { void sla_av2m_ ( const float[3],float[3][3]); }
extern"C" { void sla_el2ue_ ( const double*,const int*,double*,double*,double*,double*,double*,double*,double*,double*,double[13],int*); }
extern"C" { void sla_cr2af_ ( const int*,const float*,char*,int[4]); }
extern"C" { void sla_ecleq_ ( const double*,const double*,const double*,double*,double*); }
extern"C" { void sla_mappa_ ( const double*,const double*,double[21]); }
extern"C" { void sla_ctf2d_ ( const int*,const int*,const float*,float*,int*); }
extern"C" { void sla_unpcd_ ( const double*,double*,double*); }
extern"C" { void sla_cd2tf_ ( const int*,const float*,char*,int[4]); }
extern"C" { void sla_mxm_ ( const float[3][3],const float[3][3],float[3][3]); }
extern"C" { void sla_dfltin_ ( const char*,int*,double*,int*); }
extern"C" { void sla_plantu_ ( const double*,const double*,const double*,const double[13],double*,double*,double*,int*); }
extern"C" { float sla_pav_ ( const float[3],const float[3]); }
extern"C" { void sla_dvxv_ ( const double[3],const double[3],double[3]); }
extern"C" { void sla_altaz_ ( const double*,const double*,const double*,double*,double*,double*,double*,double*,double*,double*,double*,double*); }
extern"C" { void sla_dav2m_ ( const double[3],double[3][3]); }
extern"C" { void sla_de2h_ ( const double*,const double*,const double*,double*,double*); }
extern"C" { double sla_airmas_ ( const double*); }
extern"C" { void sla_moon_ ( const int*,const int*,const float*,float[6]); }
extern"C" { double sla_dvdv_ ( const double[3],const double[3]); }
extern"C" { void sla_dd2tf_ ( const int*,const double*,char*,int[4]); }
extern"C" { void sla_galeq_ ( const double*,const double*,double*,double*); }
extern"C" { void sla_oap_ ( const char*,const int*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,double*,double*); }
extern"C" { void sla_nutc80_ ( const double*,double*,double*,double*); }
extern"C" { void sla_planel_ ( const double*,const int*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,double[6],int*); }
extern"C" { void sla_h2fk5_ ( const double*,const double*,const double*,const double*,double*,double*,double*,double*); }
extern"C" { void sla_dmxm_ ( const double[3][3],const double[3][3],double[3][3]); }
extern"C" { void sla_vn_ ( const float[3],float[3],float*); }
extern"C" { void sla_clyd_ ( const int*,const int*,const int*,int*,int*,int*); }
extern"C" { void sla_m2av_ ( const float[3][3],float[3]); }
extern"C" { void sla_dr2tf_ ( const int*,const double*,char*,int[4]); }
extern"C" { void sla__atms_ ( const double*,const double*,const double*,const double*,const double*,double*,double*); }
extern"C" { double sla_pa_ ( const double*,const double*,const double*); }
extern"C" { void sla_dcmpf_ ( const double[6],double*,double*,double*,double*,double*,double*); }
extern"C" { double sla_dbear_ ( const double*,const double*,const double*,const double*); }
extern"C" { void sla_afin_ ( const char*,const int*,int*,float*,int*); }
extern"C" { void sla_ds2tp_ ( const double*,const double*,const double*,const double*,double*,double*,int*); }
extern"C" { void sla_dtp2s_ ( const double*,const double*,const double*,const double*,double*,double*); }
extern"C" { void sla_fk52h_ ( const double*,const double*,const double*,const double*,double*,double*,double*,double*); }
extern"C" { void sla_mapqk_ ( const double*,const double*,const double*,const double*,const double*,const double*,const double[21],double*,double*); }
extern"C" { float sla_rvlsrd_ ( const float*,const float*); }
extern"C" { double sla_dt_ ( const double*); }
extern"C" { void sla_ctf2r_ ( const int*,const int*,const float*,float*,int*); }
extern"C" { double sla_dpav_ ( const double[3],const double[3]); }
extern"C" { void sla_pertue_ ( const double*,const double[13],int*); }
extern"C" { double sla_epj_ ( const double*); }
extern"C" { void sla_atmdsp_ ( const double*,const double*,const double*,const double*,const double*,const double*,const double*,double*,double*); }
extern"C" { void sla_prebn_ ( const double*,const double*,double[3][3]); }
extern"C" { void sla_h2e_ ( const float*,const float*,const float*,float*,float*); }
extern"C" { double sla_rcc_ ( const double*,const double*,const double*,const double*,const double*); }
extern"C" { void sla_ue2el_ ( const double[13],int*,double*,double*,double*,double*,double*,double*,double*,double*,double*,int*); }
extern"C" { void sla_eg50_ ( const double*,const double*,double*,double*); }
extern"C" { void sla_invf_ ( const double[6],double[6],int*); }
extern"C" { void sla_fk45z_ ( const double*,const double*,const double*,double*,double*); }
extern"C" { void sla_dimxv_ ( const double[3][3],const double[3],double[3]); }
extern"C" { void sla_daf2r_ ( const int*,const int*,const double*,double*,int*); }
extern"C" { void sla_pdq2h_ ( const double*,const double*,const double*,double*,int*,double*,int*); }
extern"C" { void sla_dh2e_ ( const double*,const double*,const double*,double*,double*); }
extern"C" { void sla_dtps2c_ ( const double*,const double*,const double*,const double*,double*,double*,double*,double*,int*); }
extern"C" { void sla_dm2av_ ( const double[3][3],double[3]); }
extern"C" { void sla_prec_ ( const double*,const double*,double[3][3]); }
extern"C" { float sla_rvlsrk_ ( const float*,const float*); }
extern"C" { void sla_plante_ ( const double*,const double*,const double*,const int*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,double*,double*,double*,int*); }
extern"C" { double sla_epb_ ( const double*); }
extern"C" { void sla_precl_ ( const double*,const double*,double[3][3]); }
extern"C" { void sla_kbj_ ( const int*,const double*,char*,int*); }
extern"C" { void sla_pv2ue_ ( const double[6],const double*,const double*,double[13],int*); }
extern"C" { void sla_dcs2c_ ( const double*,const double*,double[3]); }
extern"C" { void sla_fk54z_ ( const double*,const double*,const double*,double*,double*,double*,double*); }
extern"C" { void sla__idchf_ ( const char*,int*,int*,int*,double*); }
extern"C" { void sla_djcl_ ( const double*,int*,int*,int*,double*,int*); }
extern"C" { double sla_eqeqx_ ( const double*); }
extern"C" { void sla_dc62s_ ( const double[6],double*,double*,double*,double*,double*,double*); }
extern"C" { void sla_eqgal_ ( const double*,const double*,double*,double*); }
extern"C" { void sla_ge50_ ( const double*,const double*,double*,double*); }
extern"C" { double sla_epco_ ( const char*,const char*,const double*); }
extern"C" { float sla_rvlg_ ( const float*,const float*); }
extern"C" { void sla_cs2c6_ ( const float*,const float*,const float*,const float*,const float*,const float*,float[6]); }
extern"C" { void sla_s2tp_ ( const float*,const float*,const float*,const float*,float*,float*,int*); }
extern"C" { void sla_cc2s_ ( const float[3],float*,float*); }
extern"C" { float sla_ranorm_ ( const double*); }
extern"C" { void sla_nut_ ( const double*,double[3][3]); }
extern"C" { void sla_v2tp_ ( const float[3],const float[3],float*,float*,int*); }
extern"C" { void sla_djcal_ ( int*,const double*,int[4],int*); }
extern"C" { void sla_dtpv2c_ ( const double*,const double*,const double[3],double[3],double[3],int*); }
extern"C" { void sla__idchi_ ( const char*,int*,int*,double*); }
extern"C" { double sla_dtt_ ( const double*); }
extern"C" { void sla_ds2c6_ ( const double*,const double*,const double*,const double*,const double*,const double*,double[6]); }
extern"C" { void sla_etrms_ ( const double*,double[3]); }
extern"C" { void sla_refcoq_ ( const double*,const double*,const double*,const double*,double*,double*); }
extern"C" { void sla_eqecl_ ( const double*,const double*,const double*,double*,double*); }
extern"C" { double sla_gmsta_ ( const double*,const double*); }
extern"C" { void sla_tps2c_ ( const float*,const float*,const float*,const float*,float*,float*,float*,float*,int*); }
extern"C" { void sla_fk425_ ( const double*,const double*,const double*,const double*,const double*,const double*,double*,double*,double*,double*,double*,double*); }
extern"C" { void sla_dv2tp_ ( const double[3],const double[3],double*,double*,int*); }
extern"C" { void sla_tp2s_ ( const float*,const float*,const float*,const float*,float*,float*); }
extern"C" { void sla_dmoon_ ( const double*,double[6]); }
extern"C" { void sla_caf2r_ ( const int*,const int*,const float*,float*,int*); }
extern"C" { void sla_earth_ ( const int*,const int*,const float*,float[6]); }
extern"C" { void sla_prenut_ ( const double*,const double*,double[3][3]); }
extern"C" { double sla_drange_ ( const double*); }
extern"C" { void sla_xy2xy_ ( const double*,const double*,const double[6],double*,double*); }
extern"C" { float sla_bear_ ( const float*,const float*,const float*,const float*); }
extern"C" { void sla_ue2pv_ ( const double*,const double[13],double[6],int*); }
extern"C" { void sla_supgal_ ( const double*,const double*,double*,double*); }
extern"C" { double sla_epj2d_ ( const double*); }
extern"C" { double sla_dat_ ( const double*); }
extern"C" { void sla_dr2af_ ( const int*,const double*,char*,int[4]); }
extern"C" { double sla_dsepv_ ( const double[3],const double[3]); }
extern"C" { void sla_addet_ ( const double*,const double*,const double*,double*,double*); }
extern"C" { void sla_refv_ ( const double*,const double*,const double*,double*); }
extern"C" { double sla_dsep_ ( const double*,const double*,const double*,const double*); }
extern"C" { void sla__atmt_ ( const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,double*,double*,double*); }
extern"C" { void sla_cc62s_ ( const float[6],float*,float*,float*,float*,float*,float*); }
extern"C" { void sla_subet_ ( const double*,const double*,const double*,double*,double*); }
extern"C" { void sla_cldj_ ( const int*,const int*,const int*,double*,int*); }
extern"C" { void sla_dtf2r_ ( const int*,const int*,const double*,double*,int*); }
extern"C" { void sla_aop_ ( const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,double*,double*,double*,double*,double*); }
extern"C" { float sla_rverot_ ( const float*,const float*,const float*,const float*); }
extern"C" { void sla_rdplan_ ( const double*,const int*,const double*,const double*,double*,double*,double*); }
extern"C" { void sla_dbjin_ ( const char*,int*,double*,int*,int*); }
extern"C" { void sla_tpv2c_ ( const float*,const float*,const float[3],float[3],float[3],int*); }
extern"C" { void sla_oapqk_ ( const char*,const int*,const double*,const double*,const double[14],double*,double*); }
extern"C" { void sla_pda2h_ ( const double*,const double*,const double*,double*,int*,double*,int*); }
extern"C" { void sla_aopqk_ ( const double*,const double*,const double[14],double*,double*,double*,double*,double*); }
extern"C" { void sla_pm_ ( const double*,const double*,const double*,const double*,const double*,const double*,const double*,const double*,double*,double*); }
extern"C" { float sla_sepv_ ( const float[3],const float[3]); }
extern"C" { void sla_intin_ ( const char*,int*,int*,int*); }
extern"C" { void sla_cr2tf_ ( const int*,const float*,char*,int[4]); }
extern"C" { void sla_planet_ ( const double*,const int*,double[6],int*); }
extern"C" { void sla_vxv_ ( const float[3],const float[3],float[3]); }
extern"C" { double sla_zd_ ( const double*,const double*,const double*); }
extern"C" { void sla_pcd_ ( const double*,double*,double*); }
extern"C" { void sla_ecor_ ( const float*,const float*,const int*,const int*,const float*,float*,float*); }
extern"C" { void sla_flotin_ ( const char*,int*,float*,int*); }
extern"C" { void sla_dtp2v_ ( const double*,const double*,const double[3],double[3]); }
extern"C" { void sla_e2h_ ( const float*,const float*,const float*,float*,float*); }
extern"C" { void sla_fk524_ ( const double*,const double*,const double*,const double*,const double*,const double*,double*,double*,double*,double*,double*,double*); }



namespace sla {
    
// helper to make a pointer to an rvalue 
#ifndef POINTABLEDEFD
#define POINTABLEDEFD
template <typename T> struct _pointable
{
  T x;
  _pointable(const T& x): x(x) {}
  operator T*() { return &x; }
};
#endif


    //     - - - - - -
//      P V 2 E L
//     - - - - - -
//
//  Heliocentric osculating elements obtained from instantaneous position
//  and velocity.
//
//  Given:
//     PV        d(6)   heliocentric x,y,z,xdot,ydot,zdot of date,
//                      J2000 equatorial triad (AU,AU/s; Note 1)
//     DATE      d      date (TT Modified Julian Date = JD-2400000.5)
//     PMASS     d      mass of the planet (Sun=1; Note 2)
//     JFORMR    i      requested element set (1-3; Note 3)
//
//  Returned:
//     JFORM     d      element set actually returned (1-3; Note 4)
//     EPOCH     d      epoch of elements (TT MJD)
//     ORBINC    d      inclination (radians)
//     ANODE     d      longitude of the ascending node (radians)
//     PERIH     d      longitude or argument of perihelion (radians)
//     AORQ      d      mean distance or perihelion distance (AU)
//     E         d      eccentricity
//     AORL      d      mean anomaly or longitude (radians, JFORM=1,2 only)
//     DM        d      daily motion (radians, JFORM=1 only)
//     JSTAT     i      status:  0 = OK
//                              -1 = illegal PMASS
//                              -2 = illegal JFORMR
//                              -3 = position/velocity out of range
//
//  Notes
//
//  1  The PV 6-vector is with respect to the mean equator and equinox of
//     epoch J2000.  The orbital elements produced are with respect to
//     the J2000 ecliptic and mean equinox.
//
//  2  The mass, PMASS, is important only for the larger planets.  For
//     most purposes (e.g. asteroids) use 0D0.  Values less than zero
//     are illegal.
//
//  3  Three different element-format options are supported:
//
//     Option JFORM=1, suitable for the major planets:
//
//     EPOCH  = epoch of elements (TT MJD)
//     ORBINC = inclination i (radians)
//     ANODE  = longitude of the ascending node, big omega (radians)
//     PERIH  = longitude of perihelion, curly pi (radians)
//     AORQ   = mean distance, a (AU)
//     E      = eccentricity, e
//     AORL   = mean longitude L (radians)
//     DM     = daily motion (radians)
//
//     Option JFORM=2, suitable for minor planets:
//
//     EPOCH  = epoch of elements (TT MJD)
//     ORBINC = inclination i (radians)
//     ANODE  = longitude of the ascending node, big omega (radians)
//     PERIH  = argument of perihelion, little omega (radians)
//     AORQ   = mean distance, a (AU)
//     E      = eccentricity, e
//     AORL   = mean anomaly M (radians)
//
//     Option JFORM=3, suitable for comets:
//
//     EPOCH  = epoch of perihelion (TT MJD)
//     ORBINC = inclination i (radians)
//     ANODE  = longitude of the ascending node, big omega (radians)
//     PERIH  = argument of perihelion, little omega (radians)
//     AORQ   = perihelion distance, q (AU)
//     E      = eccentricity, e
//
//  4  It may not be possible to generate elements in the form
//     requested through JFORMR.  The caller is notified of the form
//     of elements actually returned by means of the JFORM argument:
//
//      JFORMR   JFORM     meaning
//
//        1        1       OK - elements are in the requested format
//        1        2       never happens
//        1        3       orbit not elliptical
//
//        2        1       never happens
//        2        2       OK - elements are in the requested format
//        2        3       orbit not elliptical
//
//        3        1       never happens
//        3        2       never happens
//        3        3       OK - elements are in the requested format
//
//  5  The arguments returned for each value of JFORM (cf Note 5: JFORM
//     may not be the same as JFORMR) are as follows:
//
//         JFORM         1              2              3
//         EPOCH         t0             t0             T
//         ORBINC        i              i              i
//         ANODE         Omega          Omega          Omega
//         PERIH         curly pi       omega          omega
//         AORQ          a              a              q
//         E             e              e              e
//         AORL          L              M              -
//         DM            n              -              -
//
//     where:
//
//         t0           is the epoch of the elements (MJD, TT)
//         T              "    epoch of perihelion (MJD, TT)
//         i              "    inclination (radians)
//         Omega          "    longitude of the ascending node (radians)
//         curly pi       "    longitude of perihelion (radians)
//         omega          "    argument of perihelion (radians)
//         a              "    mean distance (AU)
//         q              "    perihelion distance (AU)
//         e              "    eccentricity
//         L              "    longitude (radians, 0-2pi)
//         M              "    mean anomaly (radians, 0-2pi)
//         n              "    daily motion (radians)
//         -             means no value is set
//
//  6  At very small inclinations, the longitude of the ascending node
//     ANODE becomes indeterminate and under some circumstances may be
//     set arbitrarily to zero.  Similarly, if the orbit is close to
//     circular, the true anomaly becomes indeterminate and under some
//     circumstances may be set arbitrarily to zero.  In such cases,
//     the other elements are automatically adjusted to compensate,
//     and so the elements remain a valid description of the orbit.
//
//  7  The osculating epoch for the returned elements is the argument
//     DATE.
//
//  Reference:  Sterne, Theodore E., "An Introduction to Celestial
//              Mechanics", Interscience Publishers, 1960
//
//  Called:  sla_DRANRM
//
//  Last revision:   8 September 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct pv2el 
{
double JFORM;double EPOCH;double ORBINC;double ANODE;double PERIH;double AORQ;double E;double AORL;double DM;int JSTAT;

  pv2el( const double PV[6],const double DATE,const double PMASS,int JFORMR )
  {
   sla_pv2el_( PV,&DATE,&PMASS,&JFORMR,&JFORM,&EPOCH,&ORBINC,&ANODE,&PERIH,&AORQ,&E,&AORL,&DM,&JSTAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "JFORM,EPOCH,ORBINC,ANODE,PERIH,AORQ,E,AORL,DM,JSTAT : " << JFORM<<" "<<EPOCH<<" "<<ORBINC<<" "<<ANODE<<" "<<PERIH<<" "<<AORQ<<" "<<E<<" "<<AORL<<" "<<DM<<" "<<JSTAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const pv2el& o ) { return s << o.__str__(); }

//     - - - - -
//      G E O C
//     - - - - -
//
//  Convert geodetic position to geocentric (double precision)
//
//  Given:
//     P     dp     latitude (geodetic, radians)
//     H     dp     height above reference spheroid (geodetic, metres)
//
//  Returned:
//     R     dp     distance from Earth axis (AU)
//     Z     dp     distance from plane of Earth equator (AU)
//
//  Notes:
//
//  1  Geocentric latitude can be obtained by evaluating ATAN2(Z,R).
//
//  2  IAU 1976 constants are used.
//
//  Reference:
//
//     Green,R.M., Spherical Astronomy, CUP 1985, p98.
//
//  Last revision:   22 July 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct geoc 
{
double R;double Z;

  geoc( const double P,const double H )
  {
   sla_geoc_( &P,&H,&R,&Z );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "R,Z : " << R<<" "<<Z << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const geoc& o ) { return s << o.__str__(); }

//     - - - -
//      S E P
//     - - - -
//
//  Angle between two points on a sphere.
//
//  (single precision)
//
//  Given:
//     A1,B1    r     spherical coordinates of one point
//     A2,B2    r     spherical coordinates of the other point
//
//  (The spherical coordinates are [RA,Dec], [Long,Lat] etc, in radians.)
//
//  The result is the angle, in radians, between the two points.  It
//  is always positive.
//
//  Called:  sla_DSEP
//
//  Last revision:   7 May 2000
//
//  Copyright P.T.Wallace.  All rights reserved.
//


inline float sep( const float A1,const float B1,const float A2,const float B2 )
{
 return sla_sep_( &A1,&B1,&A2,&B2 );
};
//     - - - - - -
//      A M P Q K
//     - - - - - -
//
//  Convert star RA,Dec from geocentric apparent to mean place
//
//  The mean coordinate system is the post IAU 1976 system,
//  loosely called FK5.
//
//  Use of this routine is appropriate when efficiency is important
//  and where many star positions are all to be transformed for
//  one epoch and equinox.  The star-independent parameters can be
//  obtained by calling the sla_MAPPA routine.
//
//  Given:
//     RA       d      apparent RA (radians)
//     DA       d      apparent Dec (radians)
//
//     AMPRMS   d(21)  star-independent mean-to-apparent parameters:
//
//       (1)      time interval for proper motion (Julian years)
//       (2-4)    barycentric position of the Earth (AU)
//       (5-7)    heliocentric direction of the Earth (unit vector)
//       (8)      (grav rad Sun)*2/(Sun-Earth distance)
//       (9-11)   ABV: barycentric Earth velocity in units of c
//       (12)     sqrt(1-v**2) where v=modulus(ABV)
//       (13-21)  precession/nutation (3,3) matrix
//
//  Returned:
//     RM       d      mean RA (radians)
//     DM       d      mean Dec (radians)
//
//  References:
//     1984 Astronomical Almanac, pp B39-B41.
//     (also Lederle & Schwan, Astron. Astrophys. 134,
//      1-6, 1984)
//
//  Note:
//
//     Iterative techniques are used for the aberration and
//     light deflection corrections so that the routines
//     sla_AMP (or sla_AMPQK) and sla_MAP (or sla_MAPQK) are
//     accurate inverses;  even at the edge of the Sun's disc
//     the discrepancy is only about 1 nanoarcsecond.
//
//  Called:  sla_DCS2C, sla_DIMXV, sla_DVDV, sla_DVN, sla_DCC2S,
//           sla_DRANRM
//
//  P.T.Wallace   Starlink   7 May 2000
//
//  Copyright (C) 2000 Rutherford Appleton Laboratory
//


struct ampqk 
{
double RM;double DM;

  ampqk( const double RA,const double DA,const double AMPRMS[21] )
  {
   sla_ampqk_( &RA,&DA,AMPRMS,&RM,&DM );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RM,DM : " << RM<<" "<<DM << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const ampqk& o ) { return s << o.__str__(); }

//     - - - - - - -
//      A O P P A T
//     - - - - - - -
//
//  Recompute the sidereal time in the apparent to observed place
//  star-independent parameter block.
//
//  Given:
//     DATE   d      UTC date/time (modified Julian Date, JD-2400000.5)
//                   (see AOPPA source for comments on leap seconds)
//
//     AOPRMS d(14)  star-independent apparent-to-observed parameters
//
//       (1-12)   not required
//       (13)     longitude + eqn of equinoxes + sidereal DUT
//       (14)     not required
//
//  Returned:
//     AOPRMS d(14)  star-independent apparent-to-observed parameters:
//
//       (1-13)   not changed
//       (14)     local apparent sidereal time (radians)
//
//  For more information, see sla_AOPPA.
//
//  Called:  sla_GMST
//
//  P.T.Wallace   Starlink   1 July 1993
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct aoppat 
{
;

  aoppat( const double DATE,double AOPRMS[14] )
  {
   sla_aoppat_( &DATE,AOPRMS );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << " : " << "<obj holds not state>" << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const aoppat& o ) { return s << o.__str__(); }

//     - - - - - -
//      E P B 2 D
//     - - - - - -
//
//  Conversion of Besselian Epoch to Modified Julian Date
//  (double precision)
//
//  Given:
//     EPB      dp       Besselian Epoch
//
//  The result is the Modified Julian Date (JD - 2400000.5).
//
//  Reference:
//     Lieske,J.H., 1979. Astron.Astrophys.,73,282.
//
//  P.T.Wallace   Starlink   February 1984
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline double epb2d( const double EPB )
{
 return sla_epb2d_( &EPB );
};
//     - - - - - -
//      D A F I N
//     - - - - - -
//
//  Sexagesimal character string to angle (double precision)
//
//  Given:
//     STRING  c*(*)   string containing deg, arcmin, arcsec fields
//     IPTR      i     pointer to start of decode (1st = 1)
//
//  Returned:
//     IPTR      i     advanced past the decoded angle
//     A         d     angle in radians
//     J         i     status:  0 = OK
//                             +1 = default, A unchanged
//                             -1 = bad degrees      )
//                             -2 = bad arcminutes   )  (note 3)
//                             -3 = bad arcseconds   )
//
//  Example:
//
//    argument    before                           after
//
//    STRING      '-57 17 44.806  12 34 56.7'      unchanged
//    IPTR        1                                16 (points to 12...)
//    A           ?                                -1.00000D0
//    J           ?                                0
//
//    A further call to sla_DAFIN, without adjustment of IPTR, will
//    decode the second angle, 12deg 34min 56.7sec.
//
//  Notes:
//
//     1)  The first three "fields" in STRING are degrees, arcminutes,
//         arcseconds, separated by spaces or commas.  The degrees field
//         may be signed, but not the others.  The decoding is carried
//         out by the DFLTIN routine and is free-format.
//
//     2)  Successive fields may be absent, defaulting to zero.  For
//         zero status, the only combinations allowed are degrees alone,
//         degrees and arcminutes, and all three fields present.  If all
//         three fields are omitted, a status of +1 is returned and A is
//         unchanged.  In all other cases A is changed.
//
//     3)  Range checking:
//
//           The degrees field is not range checked.  However, it is
//           expected to be integral unless the other two fields are absent.
//
//           The arcminutes field is expected to be 0-59, and integral if
//           the arcseconds field is present.  If the arcseconds field
//           is absent, the arcminutes is expected to be 0-59.9999...
//
//           The arcseconds field is expected to be 0-59.9999...
//
//     4)  Decoding continues even when a check has failed.  Under these
//         circumstances the field takes the supplied value, defaulting
//         to zero, and the result A is computed and returned.
//
//     5)  Further fields after the three expected ones are not treated
//         as an error.  The pointer IPTR is left in the correct state
//         for further decoding with the present routine or with DFLTIN
//         etc. See the example, above.
//
//     6)  If STRING contains hours, minutes, seconds instead of degrees
//         etc, or if the required units are turns (or days) instead of
//         radians, the result A should be multiplied as follows:
//
//           for        to obtain    multiply
//           STRING     A in         A by
//
//           d ' "      radians      1       =  1D0
//           d ' "      turns        1/2pi   =  0.1591549430918953358D0
//           h m s      radians      15      =  15D0
//           h m s      days         15/2pi  =  2.3873241463784300365D0
//
//  Called:  sla_DFLTIN
//
//  P.T.Wallace   Starlink   1 August 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct dafin 
{
double A;int J;

  dafin( const string& STRING,int IPTR )
  {
   sla_dafin_( STRING.c_str(),_pointable<int>(STRING.length()),&IPTR,&A,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "A,J : " << A<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dafin& o ) { return s << o.__str__(); }

//     - - - - - -
//      E C M A T
//     - - - - - -
//
//  Form the equatorial to ecliptic rotation matrix - IAU 1980 theory
//  (double precision)
//
//  Given:
//     DATE     dp         TDB (loosely ET) as Modified Julian Date
//                                            (JD-2400000.5)
//  Returned:
//     RMAT     dp(3,3)    matrix
//
//  Reference:
//     Murray,C.A., Vectorial Astrometry, section 4.3.
//
//  Note:
//    The matrix is in the sense   V(ecl)  =  RMAT * V(equ);  the
//    equator, equinox and ecliptic are mean of date.
//
//  Called:  sla_DEULER
//
//  P.T.Wallace   Starlink   23 August 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct ecmat 
{
double RMAT[3][3];

  ecmat( const double DATE )
  {
   sla_ecmat_( &DATE,RMAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RMAT : " << RMAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const ecmat& o ) { return s << o.__str__(); }

//     - - - -
//      A M P
//     - - - -
//
//  Convert star RA,Dec from geocentric apparent to mean place
//
//  The mean coordinate system is the post IAU 1976 system,
//  loosely called FK5.
//
//  Given:
//     RA       d      apparent RA (radians)
//     DA       d      apparent Dec (radians)
//     DATE     d      TDB for apparent place (JD-2400000.5)
//     EQ       d      equinox:  Julian epoch of mean place
//
//  Returned:
//     RM       d      mean RA (radians)
//     DM       d      mean Dec (radians)
//
//  References:
//     1984 Astronomical Almanac, pp B39-B41.
//     (also Lederle & Schwan, Astron. Astrophys. 134,
//      1-6, 1984)
//
//  Notes:
//
//  1)  The distinction between the required TDB and TT is always
//      negligible.  Moreover, for all but the most critical
//      applications UTC is adequate.
//
//  2)  Iterative techniques are used for the aberration and light
//      deflection corrections so that the routines sla_AMP (or
//      sla_AMPQK) and sla_MAP (or sla_MAPQK) are accurate inverses;
//      even at the edge of the Sun's disc the discrepancy is only
//      about 1 nanoarcsecond.
//
//  3)  Where multiple apparent places are to be converted to mean
//      places, for a fixed date and equinox, it is more efficient to
//      use the sla_MAPPA routine to compute the required parameters
//      once, followed by one call to sla_AMPQK per star.
//
//  4)  The accuracy is sub-milliarcsecond, limited by the
//      precession-nutation model (IAU 1976 precession, Shirai &
//      Fukushima 2001 forced nutation and precession corrections).
//
//  5)  The accuracy is further limited by the routine sla_EVP, called
//      by sla_MAPPA, which computes the Earth position and velocity
//      using the methods of Stumpff.  The maximum error is about
//      0.3 mas.
//
//  Called:  sla_MAPPA, sla_AMPQK
//
//  P.T.Wallace   Starlink   17 September 2001
//
//  Copyright (C) 2001 Rutherford Appleton Laboratory
//


struct amp 
{
double RM;double DM;

  amp( const double RA,const double DA,const double DATE,const double EQ )
  {
   sla_amp_( &RA,&DA,&DATE,&EQ,&RM,&DM );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RM,DM : " << RM<<" "<<DM << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const amp& o ) { return s << o.__str__(); }

//     - - - - -
//      T P 2 V
//     - - - - -
//
//  Given the tangent-plane coordinates of a star and the direction
//  cosines of the tangent point, determine the direction cosines
//  of the star.
//
//  (single precision)
//
//  Given:
//     XI,ETA    r       tangent plane coordinates of star
//     V0        r(3)    direction cosines of tangent point
//
//  Returned:
//     V         r(3)    direction cosines of star
//
//  Notes:
//
//  1  If vector V0 is not of unit length, the returned vector V will
//     be wrong.
//
//  2  If vector V0 points at a pole, the returned vector V will be
//     based on the arbitrary assumption that the RA of the tangent
//     point is zero.
//
//  3  This routine is the Cartesian equivalent of the routine sla_TP2S.
//
//  P.T.Wallace   Starlink   11 February 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct tp2v 
{
float V[3];

  tp2v( const float XI,const float ETA,const float V0[3] )
  {
   sla_tp2v_( &XI,&ETA,V0,V );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "V : " << V << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const tp2v& o ) { return s << o.__str__(); }

//     - - - - -
//      R E F Z
//     - - - - -
//
//  Adjust an unrefracted zenith distance to include the effect of
//  atmospheric refraction, using the simple A tan Z + B tan**3 Z
//  model (plus special handling for large ZDs).
//
//  Given:
//    ZU    dp    unrefracted zenith distance of the source (radian)
//    REFA  dp    tan Z coefficient (radian)
//    REFB  dp    tan**3 Z coefficient (radian)
//
//  Returned:
//    ZR    dp    refracted zenith distance (radian)
//
//  Notes:
//
//  1  This routine applies the adjustment for refraction in the
//     opposite sense to the usual one - it takes an unrefracted
//     (in vacuo) position and produces an observed (refracted)
//     position, whereas the A tan Z + B tan**3 Z model strictly
//     applies to the case where an observed position is to have the
//     refraction removed.  The unrefracted to refracted case is
//     harder, and requires an inverted form of the text-book
//     refraction models;  the formula used here is based on the
//     Newton-Raphson method.  For the utmost numerical consistency
//     with the refracted to unrefracted model, two iterations are
//     carried out, achieving agreement at the 1D-11 arcseconds level
//     for a ZD of 80 degrees.  The inherent accuracy of the model
//     is, of course, far worse than this - see the documentation for
//     sla_REFCO for more information.
//
//  2  At ZD 83 degrees, the rapidly-worsening A tan Z + B tan^3 Z
//     model is abandoned and an empirical formula takes over.  For
//     optical/IR wavelengths, over a wide range of observer heights and
//     corresponding temperatures and pressures, the following levels of
//     accuracy (arcsec, worst case) are achieved, relative to numerical
//     integration through a model atmosphere:
//
//              ZR    error
//
//              80      0.7
//              81      1.3
//              82      2.4
//              83      4.7
//              84      6.2
//              85      6.4
//              86      8
//              87     10
//              88     15
//              89     30
//              90     60
//              91    150         } relevant only to
//              92    400         } high-elevation sites
//
//     For radio wavelengths the errors are typically 50% larger than
//     the optical figures and by ZD 85 deg are twice as bad, worsening
//     rapidly below that.  To maintain 1 arcsec accuracy down to ZD=85
//     at the Green Bank site, Condon (2004) has suggested amplifying
//     the amount of refraction predicted by sla_REFZ below 10.8 deg
//     elevation by the factor (1+0.00195*(10.8-E_t)), where E_t is the
//     unrefracted elevation in degrees.
//
//     The high-ZD model is scaled to match the normal model at the
//     transition point;  there is no glitch.
//
//  3  Beyond 93 deg zenith distance, the refraction is held at its
//     93 deg value.
//
//  4  See also the routine sla_REFV, which performs the adjustment in
//     Cartesian Az/El coordinates, and with the emphasis on speed
//     rather than numerical accuracy.
//
//  Reference:
//
//     Condon,J.J., Refraction Corrections for the GBT, PTCS/PN/35.2,
//     NRAO Green Bank, 2004.
//
//  P.T.Wallace   Starlink   9 April 2004
//
//  Copyright (C) 2004 Rutherford Appleton Laboratory
//


struct refz 
{
double ZR;

  refz( const double ZU,const double REFA,const double REFB )
  {
   sla_refz_( &ZU,&REFA,&REFB,&ZR );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "ZR : " << ZR << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const refz& o ) { return s << o.__str__(); }

//     - - - - - -
//      C A L D J
//     - - - - - -
//
//  Gregorian Calendar to Modified Julian Date
//
//  (Includes century default feature:  use sla_CLDJ for years
//   before 100AD.)
//
//  Given:
//     IY,IM,ID     int    year, month, day in Gregorian calendar
//
//  Returned:
//     DJM          dp     modified Julian Date (JD-2400000.5) for 0 hrs
//     J            int    status:
//                           0 = OK
//                           1 = bad year   (MJD not computed)
//                           2 = bad month  (MJD not computed)
//                           3 = bad day    (MJD computed)
//
//  Acceptable years are 00-49, interpreted as 2000-2049,
//                       50-99,     "       "  1950-1999,
//                       100 upwards, interpreted literally.
//
//  Called:  sla_CLDJ
//
//  P.T.Wallace   Starlink   November 1985
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct caldj 
{
double DJM;int J;

  caldj( const int IY,const int IM,const int ID )
  {
   sla_caldj_( &IY,&IM,&ID,&DJM,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DJM,J : " << DJM<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const caldj& o ) { return s << o.__str__(); }

//     - - - - -
//      G M S T
//     - - - - -
//
//  Conversion from universal time to sidereal time (double precision)
//
//  Given:
//    UT1    dp     universal time (strictly UT1) expressed as
//                  modified Julian Date (JD-2400000.5)
//
//  The result is the Greenwich mean sidereal time (double
//  precision, radians).
//
//  The IAU 1982 expression (see page S15 of 1984 Astronomical Almanac)
//  is used, but rearranged to reduce rounding errors.  This expression
//  is always described as giving the GMST at 0 hours UT.  In fact, it
//  gives the difference between the GMST and the UT, which happens to
//  equal the GMST (modulo 24 hours) at 0 hours UT each day.  In this
//  routine, the entire UT is used directly as the argument for the
//  standard formula, and the fractional part of the UT is added
//  separately.  Note that the factor 1.0027379... does not appear in the
//  IAU 1982 expression explicitly but in the form of the coefficient
//  8640184.812866, which is 86400x36525x0.0027379...
//
//  See also the routine sla_GMSTA, which delivers better numerical
//  precision by accepting the UT date and time as separate arguments.
//
//  Called:  sla_DRANRM
//
//  P.T.Wallace   Starlink   14 October 2001
//
//  Copyright (C) 2001 Rutherford Appleton Laboratory
//


inline double gmst( const double UT1 )
{
 return sla_gmst_( &UT1 );
};
//     - - - - - -
//      C A L Y D
//     - - - - - -
//
//  Gregorian calendar date to year and day in year (in a Julian
//  calendar aligned to the 20th/21st century Gregorian calendar).
//
//  (Includes century default feature:  use sla_CLYD for years
//   before 100AD.)
//
//  Given:
//     IY,IM,ID   int    year, month, day in Gregorian calendar
//                       (year may optionally omit the century)
//  Returned:
//     NY         int    year (re-aligned Julian calendar)
//     ND         int    day in year (1 = January 1st)
//     J          int    status:
//                         0 = OK
//                         1 = bad year (before -4711)
//                         2 = bad month
//                         3 = bad day (but conversion performed)
//
//  Notes:
//
//  1  This routine exists to support the low-precision routines
//     sla_EARTH, sla_MOON and sla_ECOR.
//
//  2  Between 1900 March 1 and 2100 February 28 it returns answers
//     which are consistent with the ordinary Gregorian calendar.
//     Outside this range there will be a discrepancy which increases
//     by one day for every non-leap century year.
//
//  3  Years in the range 50-99 are interpreted as 1950-1999, and
//     years in the range 00-49 are interpreted as 2000-2049.
//
//  Called:  sla_CLYD
//
//  P.T.Wallace   Starlink   23 November 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct calyd 
{
int NY;int ND;int J;

  calyd( const int IY,const int IM,const int ID )
  {
   sla_calyd_( &IY,&IM,&ID,&NY,&ND,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "NY,ND,J : " << NY<<" "<<ND<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const calyd& o ) { return s << o.__str__(); }

//     - - - - - - -
//      R V G A L C
//     - - - - - - -
//
//  Velocity component in a given direction due to the rotation
//  of the Galaxy (single precision)
//
//  Given:
//     R2000,D2000   real    J2000.0 mean RA,Dec (radians)
//
//  Result:
//     Component of dynamical LSR motion in direction R2000,D2000 (km/s)
//
//  Sign convention:
//     The result is +ve when the dynamical LSR is receding from the
//     given point on the sky.
//
//  Note:  The Local Standard of Rest used here is a point in the
//         vicinity of the Sun which is in a circular orbit around
//         the Galactic centre.  Sometimes called the "dynamical" LSR,
//         it is not to be confused with a "kinematical" LSR, which
//         is the mean standard of rest of star catalogues or stellar
//         populations.
//
//  Reference:  The orbital speed of 220 km/s used here comes from
//              Kerr & Lynden-Bell (1986), MNRAS, 221, p1023.
//
//  Called:
//     sla_CS2C, sla_VDV
//
//  P.T.Wallace   Starlink   23 March 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline float rvgalc( const float R2000,const float D2000 )
{
 return sla_rvgalc_( &R2000,&D2000 );
};
//     - - - -
//      M X V
//     - - - -
//
//  Performs the 3-D forward unitary transformation:
//
//     vector VB = matrix RM * vector VA
//
//  (single precision)
//
//  Given:
//     RM       real(3,3)    matrix
//     VA       real(3)      vector
//
//  Returned:
//     VB       real(3)      result vector
//
//  To comply with the ANSI Fortran 77 standard, VA and VB must be
//  different arrays.  However, the routine is coded so as to work
//  properly on many platforms even if this rule is violated.
//
//  Last revision:   26 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct mxv 
{
float VB[3];

  mxv( const float RM[3][3],const float VA[3] )
  {
   sla_mxv_( RM,VA,VB );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "VB : " << VB << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const mxv& o ) { return s << o.__str__(); }

//  - - - -
//   E P V
//  - - - -
//
//  Earth position and velocity, heliocentric and barycentric, with
//  respect to the Barycentric Celestial Reference System.
//
//  Given:
//     DATE      d         date, TDB Modified Julian Date (Note 1)
//
//  Returned:
//     PH        d(3)      heliocentric Earth position (AU)
//     VH        d(3)      heliocentric Earth velocity (AU,AU/day)
//     PB        d(3)      barycentric Earth position (AU)
//     VB        d(3)      barycentric Earth velocity (AU/day)
//
//  Notes:
//
//  1) The date is TDB as an MJD (=JD-2400000.5).  TT can be used instead
//     of TDB in most applications.
//
//  2) On return, the arrays PH, VH, PV, PB contain the following:
//
//        PH(1)    x       }
//        PH(2)    y       } heliocentric position, AU
//        PH(3)    z       }
//
//        VH(1)    xdot    }
//        VH(2)    ydot    } heliocentric velocity, AU/d
//        VH(3)    zdot    }
//
//        PB(1)    x       }
//        PB(2)    y       } barycentric position, AU
//        PB(3)    z       }
//
//        VB(1)    xdot    }
//        VB(2)    ydot    } barycentric velocity, AU/d
//        VB(3)    zdot    }
//
//     The vectors are with respect to the Barycentric Celestial
//     Reference System (BCRS); velocities are in AU per TDB day.
//
//  3) The routine is a SIMPLIFIED SOLUTION from the planetary theory
//     VSOP2000 (X. Moisson, P. Bretagnon, 2001, Celes. Mechanics &
//     Dyn. Astron., 80, 3/4, 205-213) and is an adaptation of original
//     Fortran code supplied by P. Bretagnon (private comm., 2000).
//
//  4) Comparisons over the time span 1900-2100 with this simplified
//     solution and the JPL DE405 ephemeris give the following results:
//
//                                RMS    max
//           Heliocentric:
//              position error    3.7   11.2   km
//              velocity error    1.4    5.0   mm/s
//
//           Barycentric:
//              position error    4.6   13.4   km
//              velocity error    1.4    4.9   mm/s
//
//     The results deteriorate outside this time span.
//
//  5) The routine sla_EVP is faster but less accurate.  The present
//     routine targets the case where high accuracy is more important
//     than CPU time, yet the extra complication of reading a pre-
//     computed ephemeris is not justified.
//
//  Last revision:   7 April 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//
//


struct epv 
{
double PH[3];double VH[3];double PB[3];double VB[3];

  epv( const double DATE )
  {
   sla_epv_( &DATE,PH,VH,PB,VB );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "PH,VH,PB,VB : " << PH<<" "<<VH<<" "<<PB<<" "<<VB << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const epv& o ) { return s << o.__str__(); }

//     - - - - - - -
//      D R A N R M
//     - - - - - - -
//
//  Normalize angle into range 0-2 pi  (double precision)
//
//  Given:
//     ANGLE     dp      the angle in radians
//
//  The result is ANGLE expressed in the range 0-2 pi.
//
//  Last revision:   22 July 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


inline double dranrm( const double ANGLE )
{
 return sla_dranrm_( &ANGLE );
};
//     - - - - - -
//      D T F 2 D
//     - - - - - -
//
//  Convert hours, minutes, seconds to days (double precision)
//
//  Given:
//     IHOUR       int       hours
//     IMIN        int       minutes
//     SEC         dp        seconds
//
//  Returned:
//     DAYS        dp        interval in days
//     J           int       status:  0 = OK
//                                    1 = IHOUR outside range 0-23
//                                    2 = IMIN outside range 0-59
//                                    3 = SEC outside range 0-59.999...
//
//  Notes:
//
//     1)  The result is computed even if any of the range checks fail.
//
//     2)  The sign must be dealt with outside this routine.
//
//  P.T.Wallace   Starlink   July 1984
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct dtf2d 
{
double DAYS;int J;

  dtf2d( const int IHOUR,const int IMIN,const double SEC )
  {
   sla_dtf2d_( &IHOUR,&IMIN,&SEC,&DAYS,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DAYS,J : " << DAYS<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dtf2d& o ) { return s << o.__str__(); }

//     - - - - - - -
//      G A L S U P
//     - - - - - - -
//
//  Transformation from IAU 1958 galactic coordinates to
//  de Vaucouleurs supergalactic coordinates (double precision)
//
//  Given:
//     DL,DB       dp       galactic longitude and latitude L2,B2
//
//  Returned:
//     DSL,DSB     dp       supergalactic longitude and latitude
//
//  (all arguments are radians)
//
//  Called:
//     sla_DCS2C, sla_DMXV, sla_DCC2S, sla_DRANRM, sla_DRANGE
//
//  References:
//
//     de Vaucouleurs, de Vaucouleurs, & Corwin, Second Reference
//     Catalogue of Bright Galaxies, U. Texas, page 8.
//
//     Systems & Applied Sciences Corp., Documentation for the
//     machine-readable version of the above catalogue,
//     Contract NAS 5-26490.
//
//    (These two references give different values for the galactic
//     longitude of the supergalactic origin.  Both are wrong;  the
//     correct value is L2=137.37.)
//
//  P.T.Wallace   Starlink   25 January 1999
//
//  Copyright (C) 1999 Rutherford Appleton Laboratory
//


struct galsup 
{
double DSL;double DSB;

  galsup( const double DL,const double DB )
  {
   sla_galsup_( &DL,&DB,&DSL,&DSB );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DSL,DSB : " << DSL<<" "<<DSB << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const galsup& o ) { return s << o.__str__(); }

//     - - - - - - -
//      P R E C E S
//     - - - - - - -
//
//  Precession - either FK4 (Bessel-Newcomb, pre IAU 1976) or
//  FK5 (Fricke, post IAU 1976) as required.
//
//  Given:
//     SYSTEM     char   precession to be applied: 'FK4' or 'FK5'
//     EP0,EP1    dp     starting and ending epoch
//     RA,DC      dp     RA,Dec, mean equator & equinox of epoch EP0
//
//  Returned:
//     RA,DC      dp     RA,Dec, mean equator & equinox of epoch EP1
//
//  Called:    sla_DRANRM, sla_PREBN, sla_PREC, sla_DCS2C,
//             sla_DMXV, sla_DCC2S
//
//  Notes:
//
//     1)  Lowercase characters in SYSTEM are acceptable.
//
//     2)  The epochs are Besselian if SYSTEM='FK4' and Julian if 'FK5'.
//         For example, to precess coordinates in the old system from
//         equinox 1900.0 to 1950.0 the call would be:
//             CALL sla_PRECES ('FK4', 1900D0, 1950D0, RA, DC)
//
//     3)  This routine will NOT correctly convert between the old and
//         the new systems - for example conversion from B1950 to J2000.
//         For these purposes see sla_FK425, sla_FK524, sla_FK45Z and
//         sla_FK54Z.
//
//     4)  If an invalid SYSTEM is supplied, values of -99D0,-99D0 will
//         be returned for both RA and DC.
//
//  P.T.Wallace   Starlink   20 April 1990
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct preces 
{
;

  preces( const char SYSTEM,const double EP0,const double EP1,double RA,double DC )
  {
   sla_preces_( &SYSTEM,&EP0,&EP1,&RA,&DC );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << " : " << "<obj holds not state>" << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const preces& o ) { return s << o.__str__(); }

//     - - - - - -
//      E U L E R
//     - - - - - -
//
//  Form a rotation matrix from the Euler angles - three successive
//  rotations about specified Cartesian axes (single precision)
//
//  Given:
//    ORDER  c*(*)    specifies about which axes the rotations occur
//    PHI    r        1st rotation (radians)
//    THETA  r        2nd rotation (   "   )
//    PSI    r        3rd rotation (   "   )
//
//  Returned:
//    RMAT   r(3,3)   rotation matrix
//
//  A rotation is positive when the reference frame rotates
//  anticlockwise as seen looking towards the origin from the
//  positive region of the specified axis.
//
//  The characters of ORDER define which axes the three successive
//  rotations are about.  A typical value is 'ZXZ', indicating that
//  RMAT is to become the direction cosine matrix corresponding to
//  rotations of the reference frame through PHI radians about the
//  old Z-axis, followed by THETA radians about the resulting X-axis,
//  then PSI radians about the resulting Z-axis.
//
//  The axis names can be any of the following, in any order or
//  combination:  X, Y, Z, uppercase or lowercase, 1, 2, 3.  Normal
//  axis labelling/numbering conventions apply;  the xyz (=123)
//  triad is right-handed.  Thus, the 'ZXZ' example given above
//  could be written 'zxz' or '313' (or even 'ZxZ' or '3xZ').  ORDER
//  is terminated by length or by the first unrecognized character.
//
//  Fewer than three rotations are acceptable, in which case the later
//  angle arguments are ignored.  If all rotations are zero, the
//  identity matrix is produced.
//
//  Called:  sla_DEULER
//
//  P.T.Wallace   Starlink   23 May 1997
//
//  Copyright (C) 1997 Rutherford Appleton Laboratory
//


struct euler 
{
float RMAT[3][3];

  euler( const string& ORDER,const float PHI,const float THETA,const float PSI )
  {
   sla_euler_( ORDER.c_str(),_pointable<int>(ORDER.length()),&PHI,&THETA,&PSI,RMAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RMAT : " << RMAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const euler& o ) { return s << o.__str__(); }

//     - - - - -
//      N U T C
//     - - - - -
//
//  Nutation:  longitude & obliquity components and mean obliquity,
//  using the Shirai & Fukushima (2001) theory.
//
//  Given:
//     DATE        d    TDB (loosely ET) as Modified Julian Date
//                                            (JD-2400000.5)
//  Returned:
//     DPSI,DEPS   d    nutation in longitude,obliquity
//     EPS0        d    mean obliquity
//
//  Notes:
//
//  1  The routine predicts forced nutation (but not free core nutation)
//     plus corrections to the IAU 1976 precession model.
//
//  2  Earth attitude predictions made by combining the present nutation
//     model with IAU 1976 precession are accurate to 1 mas (with respect
//     to the ICRF) for a few decades around 2000.
//
//  3  The sla_NUTC80 routine is the equivalent of the present routine
//     but using the IAU 1980 nutation theory.  The older theory is less
//     accurate, leading to errors as large as 350 mas over the interval
//     1900-2100, mainly because of the error in the IAU 1976 precession.
//
//  References:
//
//     Shirai, T. & Fukushima, T., Astron.J. 121, 3270-3283 (2001).
//
//     Fukushima, T., Astron.Astrophys. 244, L11 (1991).
//
//     Simon, J. L., Bretagnon, P., Chapront, J., Chapront-Touze, M.,
//     Francou, G. & Laskar, J., Astron.Astrophys. 282, 663 (1994).
//
//  This revision:   24 November 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct nutc 
{
double DPSI;double DEPS;double EPS0;

  nutc( const double DATE )
  {
   sla_nutc_( &DATE,&DPSI,&DEPS,&EPS0 );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DPSI,DEPS,EPS0 : " << DPSI<<" "<<DEPS<<" "<<EPS0 << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const nutc& o ) { return s << o.__str__(); }

//     - - - - - -
//      R E F C O
//     - - - - - -
//
//  Determine the constants A and B in the atmospheric refraction
//  model dZ = A tan Z + B tan**3 Z.
//
//  Z is the "observed" zenith distance (i.e. affected by refraction)
//  and dZ is what to add to Z to give the "topocentric" (i.e. in vacuo)
//  zenith distance.
//
//  Given:
//    HM      d     height of the observer above sea level (metre)
//    TDK     d     ambient temperature at the observer (K)
//    PMB     d     pressure at the observer (millibar)
//    RH      d     relative humidity at the observer (range 0-1)
//    WL      d     effective wavelength of the source (micrometre)
//    PHI     d     latitude of the observer (radian, astronomical)
//    TLR     d     temperature lapse rate in the troposphere (K/metre)
//    EPS     d     precision required to terminate iteration (radian)
//
//  Returned:
//    REFA    d     tan Z coefficient (radian)
//    REFB    d     tan**3 Z coefficient (radian)
//
//  Called:  sla_REFRO
//
//  Notes:
//
//  1  Typical values for the TLR and EPS arguments might be 0.0065D0 and
//     1D-10 respectively.
//
//  2  The radio refraction is chosen by specifying WL > 100 micrometres.
//
//  3  The routine is a slower but more accurate alternative to the
//     sla_REFCOQ routine.  The constants it produces give perfect
//     agreement with sla_REFRO at zenith distances arctan(1) (45 deg)
//     and arctan(4) (about 76 deg).  It achieves 0.5 arcsec accuracy
//     for ZD < 80 deg, 0.01 arcsec accuracy for ZD < 60 deg, and
//     0.001 arcsec accuracy for ZD < 45 deg.
//
//  P.T.Wallace   Starlink   22 May 2004
//
//  Copyright (C) 2004 Rutherford Appleton Laboratory
//


struct refco 
{
double REFA;double REFB;

  refco( const double HM,const double TDK,const double PMB,const double RH,const double WL,const double PHI,const double TLR,const double EPS )
  {
   sla_refco_( &HM,&TDK,&PMB,&RH,&WL,&PHI,&TLR,&EPS,&REFA,&REFB );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "REFA,REFB : " << REFA<<" "<<REFB << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const refco& o ) { return s << o.__str__(); }

//     - - - - - -
//      R A N G E
//     - - - - - -
//
//  Normalize angle into range +/- pi  (single precision)
//
//  Given:
//     ANGLE     dp      the angle in radians
//
//  The result is ANGLE expressed in the +/- pi (single
//  precision).
//
//  P.T.Wallace   Starlink   23 November 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline float range( const double ANGLE )
{
 return sla_range_( &ANGLE );
};
//     - - - -
//      D V N
//     - - - -
//
//  Normalizes a 3-vector also giving the modulus (double precision)
//
//  Given:
//     V       d(3)      vector
//
//  Returned:
//     UV      d(3)      unit vector in direction of V
//     VM      d         modulus of V
//
//  Notes:
//
//  1  If the modulus of V is zero, UV is set to zero as well.
//
//  2  To comply with the ANSI Fortran 77 standard, V and UV must be
//     different arrays.  However, the routine is coded so as to work
//     properly on most platforms even if this rule is violated.
//
//  Last revision:   22 July 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct dvn 
{
double UV[3];double VM;

  dvn( const double V[3] )
  {
   sla_dvn_( V,UV,&VM );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "UV,VM : " << UV<<" "<<VM << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dvn& o ) { return s << o.__str__(); }

//     - - - - - - -
//      P E R T E L
//     - - - - - - -
//
//  Update the osculating orbital elements of an asteroid or comet by
//  applying planetary perturbations.
//
//  Given (format and dates):
//     JFORM   i    choice of element set (2 or 3; Note 1)
//     DATE0   d    date of osculation (TT MJD) for the given elements
//     DATE1   d    date of osculation (TT MJD) for the updated elements
//
//  Given (the unperturbed elements):
//     EPOCH0  d    epoch (TT MJD) of the given element set (Note 2)
//     ORBI0   d    inclination (radians)
//     ANODE0  d    longitude of the ascending node (radians)
//     PERIH0  d    argument of perihelion (radians)
//     AORQ0   d    mean distance or perihelion distance (AU)
//     E0      d    eccentricity
//     AM0     d    mean anomaly (radians, JFORM=2 only)
//
//  Returned (the updated elements):
//     EPOCH1  d    epoch (TT MJD) of the updated element set (Note 2)
//     ORBI1   d    inclination (radians)
//     ANODE1  d    longitude of the ascending node (radians)
//     PERIH1  d    argument of perihelion (radians)
//     AORQ1   d    mean distance or perihelion distance (AU)
//     E1      d    eccentricity
//     AM1     d    mean anomaly (radians, JFORM=2 only)
//
//  Returned (status flag):
//     JSTAT   i    status: +102 = warning, distant epoch
//                          +101 = warning, large timespan ( > 100 years)
//                     +1 to +10 = coincident with planet (Note 6)
//                             0 = OK
//                            -1 = illegal JFORM
//                            -2 = illegal E0
//                            -3 = illegal AORQ0
//                            -4 = internal error
//                            -5 = numerical error
//
//  Notes:
//
//  1  Two different element-format options are available:
//
//     Option JFORM=2, suitable for minor planets:
//
//     EPOCH   = epoch of elements (TT MJD)
//     ORBI    = inclination i (radians)
//     ANODE   = longitude of the ascending node, big omega (radians)
//     PERIH   = argument of perihelion, little omega (radians)
//     AORQ    = mean distance, a (AU)
//     E       = eccentricity, e
//     AM      = mean anomaly M (radians)
//
//     Option JFORM=3, suitable for comets:
//
//     EPOCH   = epoch of perihelion (TT MJD)
//     ORBI    = inclination i (radians)
//     ANODE   = longitude of the ascending node, big omega (radians)
//     PERIH   = argument of perihelion, little omega (radians)
//     AORQ    = perihelion distance, q (AU)
//     E       = eccentricity, e
//
//  2  DATE0, DATE1, EPOCH0 and EPOCH1 are all instants of time in
//     the TT timescale (formerly Ephemeris Time, ET), expressed
//     as Modified Julian Dates (JD-2400000.5).
//
//     DATE0 is the instant at which the given (i.e. unperturbed)
//     osculating elements are correct.
//
//     DATE1 is the specified instant at which the updated osculating
//     elements are correct.
//
//     EPOCH0 and EPOCH1 will be the same as DATE0 and DATE1
//     (respectively) for the JFORM=2 case, normally used for minor
//     planets.  For the JFORM=3 case, the two epochs will refer to
//     perihelion passage and so will not, in general, be the same as
//     DATE0 and/or DATE1 though they may be similar to one another.
//
//  3  The elements are with respect to the J2000 ecliptic and equinox.
//
//  4  Unused elements (AM0 and AM1 for JFORM=3) are not accessed.
//
//  5  See the sla_PERTUE routine for details of the algorithm used.
//
//  6  This routine is not intended to be used for major planets, which
//     is why JFORM=1 is not available and why there is no opportunity
//     to specify either the longitude of perihelion or the daily
//     motion.  However, if JFORM=2 elements are somehow obtained for a
//     major planet and supplied to the routine, sensible results will,
//     in fact, be produced.  This happens because the sla_PERTUE routine
//     that is called to perform the calculations checks the separation
//     between the body and each of the planets and interprets a
//     suspiciously small value (0.001 AU) as an attempt to apply it to
//     the planet concerned.  If this condition is detected, the
//     contribution from that planet is ignored, and the status is set to
//     the planet number (1-10 = Mercury, Venus, EMB, Mars, Jupiter,
//     Saturn, Uranus, Neptune, Earth, Moon) as a warning.
//
//  Reference:
//
//     Sterne, Theodore E., "An Introduction to Celestial Mechanics",
//     Interscience Publishers Inc., 1960.  Section 6.7, p199.
//
//  Called:  sla_EL2UE, sla_PERTUE, sla_UE2EL
//
//  This revision:   19 June 2004
//
//  Copyright (C) 2004 P.T.Wallace.  All rights reserved.
//


struct pertel 
{
double EPOCH1;double ORBI1;double ANODE1;double PERIH1;double AORQ1;double E1;double AM1;int JSTAT;

  pertel( const int JFORM,const double DATE0,const double DATE1,const double EPOCH0,const double ORBI0,const double ANODE0,const double PERIH0,const double AORQ0,const double E0,const double AM0 )
  {
   sla_pertel_( &JFORM,&DATE0,&DATE1,&EPOCH0,&ORBI0,&ANODE0,&PERIH0,&AORQ0,&E0,&AM0,&EPOCH1,&ORBI1,&ANODE1,&PERIH1,&AORQ1,&E1,&AM1,&JSTAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "EPOCH1,ORBI1,ANODE1,PERIH1,AORQ1,E1,AM1,JSTAT : " << EPOCH1<<" "<<ORBI1<<" "<<ANODE1<<" "<<PERIH1<<" "<<AORQ1<<" "<<E1<<" "<<AM1<<" "<<JSTAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const pertel& o ) { return s << o.__str__(); }

//     - - - - - - -
//      M A P Q K Z
//     - - - - - - -
//
//  Quick mean to apparent place:  transform a star RA,Dec from
//  mean place to geocentric apparent place, given the
//  star-independent parameters, and assuming zero parallax
//  and proper motion.
//
//  Use of this routine is appropriate when efficiency is important
//  and where many star positions, all with parallax and proper
//  motion either zero or already allowed for, and all referred to
//  the same equator and equinox, are to be transformed for one
//  epoch.  The star-independent parameters can be obtained by
//  calling the sla_MAPPA routine.
//
//  The corresponding routine for the case of non-zero parallax
//  and proper motion is sla_MAPQK.
//
//  The reference frames and timescales used are post IAU 1976.
//
//  Given:
//     RM,DM    d      mean RA,Dec (rad)
//     AMPRMS   d(21)  star-independent mean-to-apparent parameters:
//
//       (1-4)    not used
//       (5-7)    heliocentric direction of the Earth (unit vector)
//       (8)      (grav rad Sun)*2/(Sun-Earth distance)
//       (9-11)   ABV: barycentric Earth velocity in units of c
//       (12)     sqrt(1-v**2) where v=modulus(ABV)
//       (13-21)  precession/nutation (3,3) matrix
//
//  Returned:
//     RA,DA    d      apparent RA,Dec (rad)
//
//  References:
//     1984 Astronomical Almanac, pp B39-B41.
//     (also Lederle & Schwan, Astron. Astrophys. 134,
//      1-6, 1984)
//
//  Notes:
//
//  1)  The vectors AMPRMS(2-4) and AMPRMS(5-7) are referred to the
//      mean equinox and equator of epoch EQ.
//
//  2)  Strictly speaking, the routine is not valid for solar-system
//      sources, though the error will usually be extremely small.
//      However, to prevent gross errors in the case where the
//      position of the Sun is specified, the gravitational
//      deflection term is restrained within about 920 arcsec of the
//      centre of the Sun's disc.  The term has a maximum value of
//      about 1.85 arcsec at this radius, and decreases to zero as
//      the centre of the disc is approached.
//
//  Called:  sla_DCS2C, sla_DVDV, sla_DMXV, sla_DCC2S, sla_DRANRM
//
//  P.T.Wallace   Starlink   18 March 1999
//
//  Copyright (C) 1999 Rutherford Appleton Laboratory
//


struct mapqkz 
{
double RA;double DA;

  mapqkz( const double RM,const double DM,const double AMPRMS[21] )
  {
   sla_mapqkz_( &RM,&DM,AMPRMS,&RA,&DA );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RA,DA : " << RA<<" "<<DA << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const mapqkz& o ) { return s << o.__str__(); }

//     - - - -
//      M A P
//     - - - -
//
//  Transform star RA,Dec from mean place to geocentric apparent
//
//  The reference frames and timescales used are post IAU 1976.
//
//  References:
//     1984 Astronomical Almanac, pp B39-B41.
//     (also Lederle & Schwan, Astron. Astrophys. 134,
//      1-6, 1984)
//
//  Given:
//     RM,DM    dp     mean RA,Dec (rad)
//     PR,PD    dp     proper motions:  RA,Dec changes per Julian year
//     PX       dp     parallax (arcsec)
//     RV       dp     radial velocity (km/sec, +ve if receding)
//     EQ       dp     epoch and equinox of star data (Julian)
//     DATE     dp     TDB for apparent place (JD-2400000.5)
//
//  Returned:
//     RA,DA    dp     apparent RA,Dec (rad)
//
//  Called:
//     sla_MAPPA       star-independent parameters
//     sla_MAPQK       quick mean to apparent
//
//  Notes:
//
//  1)  EQ is the Julian epoch specifying both the reference frame and
//      the epoch of the position - usually 2000.  For positions where
//      the epoch and equinox are different, use the routine sla_PM to
//      apply proper motion corrections before using this routine.
//
//  2)  The distinction between the required TDB and TT is always
//      negligible.  Moreover, for all but the most critical
//      applications UTC is adequate.
//
//  3)  The proper motions in RA are dRA/dt rather than cos(Dec)*dRA/dt.
//
//  4)  This routine may be wasteful for some applications because it
//      recomputes the Earth position/velocity and the precession-
//      nutation matrix each time, and because it allows for parallax
//      and proper motion.  Where multiple transformations are to be
//      carried out for one epoch, a faster method is to call the
//      sla_MAPPA routine once and then either the sla_MAPQK routine
//      (which includes parallax and proper motion) or sla_MAPQKZ (which
//      assumes zero parallax and proper motion).
//
//  5)  The accuracy is sub-milliarcsecond, limited by the
//      precession-nutation model (IAU 1976 precession, Shirai &
//      Fukushima 2001 forced nutation and precession corrections).
//
//  6)  The accuracy is further limited by the routine sla_EVP, called
//      by sla_MAPPA, which computes the Earth position and velocity
//      using the methods of Stumpff.  The maximum error is about
//      0.3 mas.
//
//  P.T.Wallace   Starlink   17 September 2001
//
//  Copyright (C) 2001 Rutherford Appleton Laboratory
//


struct map 
{
double RA;double DA;

  map( const double RM,const double DM,const double PR,const double PD,const double PX,const double RV,const double EQ,const double DATE )
  {
   sla_map_( &RM,&DM,&PR,&PD,&PX,&RV,&EQ,&DATE,&RA,&DA );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RA,DA : " << RA<<" "<<DA << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const map& o ) { return s << o.__str__(); }

//     - - - - - -
//      A O P P A
//     - - - - - -
//
//  Precompute apparent to observed place parameters required by
//  sla_AOPQK and sla_OAPQK.
//
//  Given:
//     DATE   d      UTC date/time (modified Julian Date, JD-2400000.5)
//     DUT    d      delta UT:  UT1-UTC (UTC seconds)
//     ELONGM d      mean longitude of the observer (radians, east +ve)
//     PHIM   d      mean geodetic latitude of the observer (radians)
//     HM     d      observer's height above sea level (metres)
//     XP     d      polar motion x-coordinate (radians)
//     YP     d      polar motion y-coordinate (radians)
//     TDK    d      local ambient temperature (K; std=273.15D0)
//     PMB    d      local atmospheric pressure (mb; std=1013.25D0)
//     RH     d      local relative humidity (in the range 0D0-1D0)
//     WL     d      effective wavelength (micron, e.g. 0.55D0)
//     TLR    d      tropospheric lapse rate (K/metre, e.g. 0.0065D0)
//
//  Returned:
//     AOPRMS d(14)  star-independent apparent-to-observed parameters:
//
//       (1)      geodetic latitude (radians)
//       (2,3)    sine and cosine of geodetic latitude
//       (4)      magnitude of diurnal aberration vector
//       (5)      height (HM)
//       (6)      ambient temperature (TDK)
//       (7)      pressure (PMB)
//       (8)      relative humidity (RH)
//       (9)      wavelength (WL)
//       (10)     lapse rate (TLR)
//       (11,12)  refraction constants A and B (radians)
//       (13)     longitude + eqn of equinoxes + sidereal DUT (radians)
//       (14)     local apparent sidereal time (radians)
//
//  Notes:
//
//   1)  It is advisable to take great care with units, as even
//       unlikely values of the input parameters are accepted and
//       processed in accordance with the models used.
//
//   2)  The DATE argument is UTC expressed as an MJD.  This is,
//       strictly speaking, improper, because of leap seconds.  However,
//       as long as the delta UT and the UTC are consistent there
//       are no difficulties, except during a leap second.  In this
//       case, the start of the 61st second of the final minute should
//       begin a new MJD day and the old pre-leap delta UT should
//       continue to be used.  As the 61st second completes, the MJD
//       should revert to the start of the day as, simultaneously,
//       the delta UTC changes by one second to its post-leap new value.
//
//   3)  The delta UT (UT1-UTC) is tabulated in IERS circulars and
//       elsewhere.  It increases by exactly one second at the end of
//       each UTC leap second, introduced in order to keep delta UT
//       within +/- 0.9 seconds.
//
//   4)  IMPORTANT -- TAKE CARE WITH THE LONGITUDE SIGN CONVENTION.
//       The longitude required by the present routine is east-positive,
//       in accordance with geographical convention (and right-handed).
//       In particular, note that the longitudes returned by the
//       sla_OBS routine are west-positive, following astronomical
//       usage, and must be reversed in sign before use in the present
//       routine.
//
//   5)  The polar coordinates XP,YP can be obtained from IERS
//       circulars and equivalent publications.  The maximum amplitude
//       is about 0.3 arcseconds.  If XP,YP values are unavailable,
//       use XP=YP=0D0.  See page B60 of the 1988 Astronomical Almanac
//       for a definition of the two angles.
//
//   6)  The height above sea level of the observing station, HM,
//       can be obtained from the Astronomical Almanac (Section J
//       in the 1988 edition), or via the routine sla_OBS.  If P,
//       the pressure in millibars, is available, an adequate
//       estimate of HM can be obtained from the expression
//
//             HM ~ -29.3D0*TSL*LOG(P/1013.25D0).
//
//       where TSL is the approximate sea-level air temperature in K
//       (see Astrophysical Quantities, C.W.Allen, 3rd edition,
//       section 52).  Similarly, if the pressure P is not known,
//       it can be estimated from the height of the observing
//       station, HM, as follows:
//
//             P ~ 1013.25D0*EXP(-HM/(29.3D0*TSL)).
//
//       Note, however, that the refraction is nearly proportional to the
//       pressure and that an accurate P value is important for precise
//       work.
//
//   7)  Repeated, computationally-expensive, calls to sla_AOPPA for
//       times that are very close together can be avoided by calling
//       sla_AOPPA just once and then using sla_AOPPAT for the subsequent
//       times.  Fresh calls to sla_AOPPA will be needed only when
//       changes in the precession have grown to unacceptable levels or
//       when anything affecting the refraction has changed.
//
//  Called:  sla_GEOC, sla_REFCO, sla_EQEQX, sla_AOPPAT
//
//  Last revision:   2 December 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct aoppa 
{
double AOPRMS[14];

  aoppa( const double DATE,const double DUT,const double ELONGM,const double PHIM,const double HM,const double XP,const double YP,const double TDK,const double PMB,const double RH,const double WL,const double TLR )
  {
   sla_aoppa_( &DATE,&DUT,&ELONGM,&PHIM,&HM,&XP,&YP,&TDK,&PMB,&RH,&WL,&TLR,AOPRMS );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "AOPRMS : " << AOPRMS << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const aoppa& o ) { return s << o.__str__(); }

//     - - - - - -
//      P O L M O
//     - - - - - -
//
//  Polar motion:  correct site longitude and latitude for polar
//  motion and calculate azimuth difference between celestial and
//  terrestrial poles.
//
//  Given:
//     ELONGM   d      mean longitude of the observer (radians, east +ve)
//     PHIM     d      mean geodetic latitude of the observer (radians)
//     XP       d      polar motion x-coordinate (radians)
//     YP       d      polar motion y-coordinate (radians)
//
//  Returned:
//     ELONG    d      true longitude of the observer (radians, east +ve)
//     PHI      d      true geodetic latitude of the observer (radians)
//     DAZ      d      azimuth correction (terrestrial-celestial, radians)
//
//  Notes:
//
//   1)  "Mean" longitude and latitude are the (fixed) values for the
//       site's location with respect to the IERS terrestrial reference
//       frame;  the latitude is geodetic.  TAKE CARE WITH THE LONGITUDE
//       SIGN CONVENTION.  The longitudes used by the present routine
//       are east-positive, in accordance with geographical convention
//       (and right-handed).  In particular, note that the longitudes
//       returned by the sla_OBS routine are west-positive, following
//       astronomical usage, and must be reversed in sign before use in
//       the present routine.
//
//   2)  XP and YP are the (changing) coordinates of the Celestial
//       Ephemeris Pole with respect to the IERS Reference Pole.
//       XP is positive along the meridian at longitude 0 degrees,
//       and YP is positive along the meridian at longitude
//       270 degrees (i.e. 90 degrees west).  Values for XP,YP can
//       be obtained from IERS circulars and equivalent publications;
//       the maximum amplitude observed so far is about 0.3 arcseconds.
//
//   3)  "True" longitude and latitude are the (moving) values for
//       the site's location with respect to the celestial ephemeris
//       pole and the meridian which corresponds to the Greenwich
//       apparent sidereal time.  The true longitude and latitude
//       link the terrestrial coordinates with the standard celestial
//       models (for precession, nutation, sidereal time etc).
//
//   4)  The azimuths produced by sla_AOP and sla_AOPQK are with
//       respect to due north as defined by the Celestial Ephemeris
//       Pole, and can therefore be called "celestial azimuths".
//       However, a telescope fixed to the Earth measures azimuth
//       essentially with respect to due north as defined by the
//       IERS Reference Pole, and can therefore be called "terrestrial
//       azimuth".  Uncorrected, this would manifest itself as a
//       changing "azimuth zero-point error".  The value DAZ is the
//       correction to be added to a celestial azimuth to produce
//       a terrestrial azimuth.
//
//   5)  The present routine is rigorous.  For most practical
//       purposes, the following simplified formulae provide an
//       adequate approximation:
//
//       ELONG = ELONGM+XP*COS(ELONGM)-YP*SIN(ELONGM)
//       PHI   = PHIM+(XP*SIN(ELONGM)+YP*COS(ELONGM))*TAN(PHIM)
//       DAZ   = -SQRT(XP*XP+YP*YP)*COS(ELONGM-ATAN2(XP,YP))/COS(PHIM)
//
//       An alternative formulation for DAZ is:
//
//       X = COS(ELONGM)*COS(PHIM)
//       Y = SIN(ELONGM)*COS(PHIM)
//       DAZ = ATAN2(-X*YP-Y*XP,X*X+Y*Y)
//
//   Reference:  Seidelmann, P.K. (ed), 1992.  "Explanatory Supplement
//               to the Astronomical Almanac", ISBN 0-935702-68-7,
//               sections 3.27, 4.25, 4.52.
//
//  P.T.Wallace   Starlink   30 November 2000
//
//  Copyright (C) 2000 Rutherford Appleton Laboratory
//


struct polmo 
{
double ELONG;double PHI;double DAZ;

  polmo( const double ELONGM,const double PHIM,double XP,const double YP )
  {
   sla_polmo_( &ELONGM,&PHIM,&XP,&YP,&ELONG,&PHI,&DAZ );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "ELONG,PHI,DAZ : " << ELONG<<" "<<PHI<<" "<<DAZ << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const polmo& o ) { return s << o.__str__(); }

//     - - - - -
//      D M X V
//     - - - - -
//
//  Performs the 3-D forward unitary transformation:
//
//     vector VB = matrix DM * vector VA
//
//  (double precision)
//
//  Given:
//     DM       dp(3,3)    matrix
//     VA       dp(3)      vector
//
//  Returned:
//     VB       dp(3)      result vector
//
//  To comply with the ANSI Fortran 77 standard, VA and VB must be
//  different arrays.  However, the routine is coded so as to work
//  properly on many platforms even if this rule is violated.
//
//  Last revision:   26 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct dmxv 
{
double VB[3];

  dmxv( const double DM[3][3],const double VA[3] )
  {
   sla_dmxv_( DM,VA,VB );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "VB : " << VB << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dmxv& o ) { return s << o.__str__(); }

//     - - - - - - -
//      D E U L E R
//     - - - - - - -
//
//  Form a rotation matrix from the Euler angles - three successive
//  rotations about specified Cartesian axes (double precision)
//
//  Given:
//    ORDER   c*(*)   specifies about which axes the rotations occur
//    PHI     d       1st rotation (radians)
//    THETA   d       2nd rotation (   "   )
//    PSI     d       3rd rotation (   "   )
//
//  Returned:
//    RMAT    d(3,3)  rotation matrix
//
//  A rotation is positive when the reference frame rotates
//  anticlockwise as seen looking towards the origin from the
//  positive region of the specified axis.
//
//  The characters of ORDER define which axes the three successive
//  rotations are about.  A typical value is 'ZXZ', indicating that
//  RMAT is to become the direction cosine matrix corresponding to
//  rotations of the reference frame through PHI radians about the
//  old Z-axis, followed by THETA radians about the resulting X-axis,
//  then PSI radians about the resulting Z-axis.
//
//  The axis names can be any of the following, in any order or
//  combination:  X, Y, Z, uppercase or lowercase, 1, 2, 3.  Normal
//  axis labelling/numbering conventions apply;  the xyz (=123)
//  triad is right-handed.  Thus, the 'ZXZ' example given above
//  could be written 'zxz' or '313' (or even 'ZxZ' or '3xZ').  ORDER
//  is terminated by length or by the first unrecognized character.
//
//  Fewer than three rotations are acceptable, in which case the later
//  angle arguments are ignored.  If all rotations are zero, the
//  identity matrix is produced.
//
//  P.T.Wallace   Starlink   23 May 1997
//
//  Copyright (C) 1997 Rutherford Appleton Laboratory
//


struct deuler 
{
double RMAT[3][3];

  deuler( const string& ORDER,const double PHI,const double THETA,const double PSI )
  {
   sla_deuler_( ORDER.c_str(),_pointable<int>(ORDER.length()),&PHI,&THETA,&PSI,RMAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RMAT : " << RMAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const deuler& o ) { return s << o.__str__(); }

//     - - - - -
//      C S 2 C
//     - - - - -
//
//  Spherical coordinates to direction cosines (single precision)
//
//  Given:
//     A,B      real      spherical coordinates in radians
//                           (RA,Dec), (long,lat) etc.
//
//  Returned:
//     V        real(3)   x,y,z unit vector
//
//  The spherical coordinates are longitude (+ve anticlockwise looking
//  from the +ve latitude pole) and latitude.  The Cartesian coordinates
//  are right handed, with the x axis at zero longitude and latitude, and
//  the z axis at the +ve latitude pole.
//
//  Last revision:   22 July 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct cs2c 
{
float V[3];

  cs2c( const float A,const float B )
  {
   sla_cs2c_( &A,&B,V );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "V : " << V << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const cs2c& o ) { return s << o.__str__(); }

//     - - - - -
//      I M X V
//     - - - - -
//
//  Performs the 3-D backward unitary transformation:
//
//     vector VB = (inverse of matrix RM) * vector VA
//
//  (single precision)
//
//  (n.b.  the matrix must be unitary, as this routine assumes that
//   the inverse and transpose are identical)
//
//  Given:
//     RM       real(3,3)    matrix
//     VA       real(3)      vector
//
//  Returned:
//     VB       real(3)      result vector
//
//  P.T.Wallace   Starlink   November 1984
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct imxv 
{
float VB[3];

  imxv( const float RM[3][3],const float VA[3] )
  {
   sla_imxv_( RM,VA,VB );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "VB : " << VB << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const imxv& o ) { return s << o.__str__(); }

//     - - - - - -
//      F K 5 H Z
//     - - - - - -
//
//  Transform an FK5 (J2000) star position into the frame of the
//  Hipparcos catalogue, assuming zero Hipparcos proper motion.
//
//  (double precision)
//
//  This routine converts a star position from the FK5 system to
//  the Hipparcos system, in such a way that the Hipparcos proper
//  motion is zero.  Because such a star has, in general, a non-zero
//  proper motion in the FK5 system, the routine requires the epoch
//  at which the position in the FK5 system was determined.
//
//  Given:
//     R5        d      FK5 RA (radians), equinox J2000, epoch EPOCH
//     D5        d      FK5 Dec (radians), equinox J2000, epoch EPOCH
//     EPOCH     d      Julian epoch (TDB)
//
//  Returned (all Hipparcos):
//     RH        d      RA (radians)
//     DH        d      Dec (radians)
//
//  Called:  sla_DCS2C, sla_DAV2M, sla_DIMXV, sla_DMXV, sla_DCC2S,
//           sla_DRANRM
//
//  Notes:
//
//  1)  The FK5 to Hipparcos transformation consists of a pure
//      rotation and spin;  zonal errors in the FK5 catalogue are
//      not taken into account.
//
//  2)  The published orientation and spin components are interpreted
//      as "axial vectors".  An axial vector points at the pole of the
//      rotation and its length is the amount of rotation in radians.
//
//  3)  See also sla_FK52H, sla_H2FK5, sla_HFK5Z.
//
//  Reference:
//
//     M.Feissel & F.Mignard, Astron. Astrophys. 331, L33-L36 (1998).
//
//  P.T.Wallace   Starlink   22 June 1999
//
//  Copyright (C) 1999 Rutherford Appleton Laboratory
//


struct fk5hz 
{
double RH;double DH;

  fk5hz( const double R5,const double D5,const double EPOCH )
  {
   sla_fk5hz_( &R5,&D5,&EPOCH,&RH,&DH );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RH,DH : " << RH<<" "<<DH << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const fk5hz& o ) { return s << o.__str__(); }

//     - - - -
//      V D V
//     - - - -
//
//  Scalar product of two 3-vectors  (single precision)
//
//  Given:
//      VA      real(3)     first vector
//      VB      real(3)     second vector
//
//  The result is the scalar product VA.VB (single precision)
//
//  P.T.Wallace   Starlink   November 1984
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline float vdv( const float VA[3],const float VB[3] )
{
 return sla_vdv_( VA,VB );
};
//     - - - - - -
//      D C C 2 S
//     - - - - - -
//
//  Cartesian to spherical coordinates (double precision)
//
//  Given:
//     V     d(3)   x,y,z vector
//
//  Returned:
//     A,B   d      spherical coordinates in radians
//
//  The spherical coordinates are longitude (+ve anticlockwise looking
//  from the +ve latitude pole) and latitude.  The Cartesian coordinates
//  are right handed, with the x axis at zero longitude and latitude, and
//  the z axis at the +ve latitude pole.
//
//  If V is null, zero A and B are returned.  At either pole, zero A is
//  returned.
//
//  Last revision:   22 July 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct dcc2s 
{
double A;double B;

  dcc2s( const double V[3] )
  {
   sla_dcc2s_( V,&A,&B );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "A,B : " << A<<" "<<B << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dcc2s& o ) { return s << o.__str__(); }

//     - - - - - -
//      R E F R O
//     - - - - - -
//
//  Atmospheric refraction for radio and optical/IR wavelengths.
//
//  Given:
//    ZOBS    d  observed zenith distance of the source (radian)
//    HM      d  height of the observer above sea level (metre)
//    TDK     d  ambient temperature at the observer (K)
//    PMB     d  pressure at the observer (millibar)
//    RH      d  relative humidity at the observer (range 0-1)
//    WL      d  effective wavelength of the source (micrometre)
//    PHI     d  latitude of the observer (radian, astronomical)
//    TLR     d  temperature lapse rate in the troposphere (K/metre)
//    EPS     d  precision required to terminate iteration (radian)
//
//  Returned:
//    REF     d  refraction: in vacuo ZD minus observed ZD (radian)
//
//  Notes:
//
//  1  A suggested value for the TLR argument is 0.0065D0.  The
//     refraction is significantly affected by TLR, and if studies
//     of the local atmosphere have been carried out a better TLR
//     value may be available.  The sign of the supplied TLR value
//     is ignored.
//
//  2  A suggested value for the EPS argument is 1D-8.  The result is
//     usually at least two orders of magnitude more computationally
//     precise than the supplied EPS value.
//
//  3  The routine computes the refraction for zenith distances up
//     to and a little beyond 90 deg using the method of Hohenkerk
//     and Sinclair (NAO Technical Notes 59 and 63, subsequently adopted
//     in the Explanatory Supplement, 1992 edition - see section 3.281).
//
//  4  The code is a development of the optical/IR refraction subroutine
//     AREF of C.Hohenkerk (HMNAO, September 1984), with extensions to
//     support the radio case.  Apart from merely cosmetic changes, the
//     following modifications to the original HMNAO optical/IR refraction
//     code have been made:
//
//     .  The angle arguments have been changed to radians.
//
//     .  Any value of ZOBS is allowed (see note 6, below).
//
//     .  Other argument values have been limited to safe values.
//
//     .  Murray's values for the gas constants have been used
//        (Vectorial Astrometry, Adam Hilger, 1983).
//
//     .  The numerical integration phase has been rearranged for
//        extra clarity.
//
//     .  A better model for Ps(T) has been adopted (taken from
//        Gill, Atmosphere-Ocean Dynamics, Academic Press, 1982).
//
//     .  More accurate expressions for Pwo have been adopted
//        (again from Gill 1982).
//
//     .  The formula for the water vapour pressure, given the
//        saturation pressure and the relative humidity, is from
//        Crane (1976), expression 2.5.5.
//
//     .  Provision for radio wavelengths has been added using
//        expressions devised by A.T.Sinclair, RGO (private
//        communication 1989).  The refractivity model currently
//        used is from J.M.Rueger, "Refractive Index Formulae for
//        Electronic Distance Measurement with Radio and Millimetre
//        Waves", in Unisurv Report S-68 (2002), School of Surveying
//        and Spatial Information Systems, University of New South
//        Wales, Sydney, Australia.
//
//     .  The optical refractivity for dry air is from Resolution 3 of
//        the International Association of Geodesy adopted at the XXIIth
//        General Assembly in Birmingham, UK, 1999.
//
//     .  Various small changes have been made to gain speed.
//
//  5  The radio refraction is chosen by specifying WL > 100 micrometres.
//     Because the algorithm takes no account of the ionosphere, the
//     accuracy deteriorates at low frequencies, below about 30 MHz.
//
//  6  Before use, the value of ZOBS is expressed in the range +/- pi.
//     If this ranged ZOBS is -ve, the result REF is computed from its
//     absolute value before being made -ve to match.  In addition, if
//     it has an absolute value greater than 93 deg, a fixed REF value
//     equal to the result for ZOBS = 93 deg is returned, appropriately
//     signed.
//
//  7  As in the original Hohenkerk and Sinclair algorithm, fixed values
//     of the water vapour polytrope exponent, the height of the
//     tropopause, and the height at which refraction is negligible are
//     used.
//
//  8  The radio refraction has been tested against work done by
//     Iain Coulson, JACH, (private communication 1995) for the
//     James Clerk Maxwell Telescope, Mauna Kea.  For typical conditions,
//     agreement at the 0.1 arcsec level is achieved for moderate ZD,
//     worsening to perhaps 0.5-1.0 arcsec at ZD 80 deg.  At hot and
//     humid sea-level sites the accuracy will not be as good.
//
//  9  It should be noted that the relative humidity RH is formally
//     defined in terms of "mixing ratio" rather than pressures or
//     densities as is often stated.  It is the mass of water per unit
//     mass of dry air divided by that for saturated air at the same
//     temperature and pressure (see Gill 1982).
//
//  10 The algorithm is designed for observers in the troposphere.  The
//     supplied temperature, pressure and lapse rate are assumed to be
//     for a point in the troposphere and are used to define a model
//     atmosphere with the tropopause at 11km altitude and a constant
//     temperature above that.  However, in practice, the refraction
//     values returned for stratospheric observers, at altitudes up to
//     25km, are quite usable.
//
//  Called:  sla_DRANGE, sla__ATMT, sla__ATMS
//
//  Last revision:   5 December 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct refro 
{
double REF;

  refro( const double ZOBS,const double HM,const double TDK,const double PMB,const double RH,const double WL,const double PHI,const double TLR,const double EPS )
  {
   sla_refro_( &ZOBS,&HM,&TDK,&PMB,&RH,&WL,&PHI,&TLR,&EPS,&REF );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "REF : " << REF << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const refro& o ) { return s << o.__str__(); }

//     - - - - -
//      A V 2 M
//     - - - - -
//
//  Form the rotation matrix corresponding to a given axial vector.
//
//  (single precision)
//
//  A rotation matrix describes a rotation about some arbitrary axis,
//  called the Euler axis.  The "axial vector" supplied to this routine
//  has the same direction as the Euler axis, and its magnitude is the
//  amount of rotation in radians.
//
//  Given:
//    AXVEC  r(3)     axial vector (radians)
//
//  Returned:
//    RMAT   r(3,3)   rotation matrix
//
//  If AXVEC is null, the unit matrix is returned.
//
//  The reference frame rotates clockwise as seen looking along
//  the axial vector from the origin.
//
//  Last revision:   26 November 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct av2m 
{
float RMAT[3][3];

  av2m( const float AXVEC[3] )
  {
   sla_av2m_( AXVEC,RMAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RMAT : " << RMAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const av2m& o ) { return s << o.__str__(); }

//     - - - - - -
//      E L 2 U E
//     - - - - - -
//
//  Transform conventional osculating orbital elements into "universal"
//  form.
//
//  Given:
//     DATE    d      epoch (TT MJD) of osculation (Note 3)
//     JFORM   i      choice of element set (1-3, Note 6)
//     EPOCH   d      epoch (TT MJD) of the elements
//     ORBINC  d      inclination (radians)
//     ANODE   d      longitude of the ascending node (radians)
//     PERIH   d      longitude or argument of perihelion (radians)
//     AORQ    d      mean distance or perihelion distance (AU)
//     E       d      eccentricity
//     AORL    d      mean anomaly or longitude (radians, JFORM=1,2 only)
//     DM      d      daily motion (radians, JFORM=1 only)
//
//  Returned:
//     U       d(13)  universal orbital elements (Note 1)
//
//               (1)  combined mass (M+m)
//               (2)  total energy of the orbit (alpha)
//               (3)  reference (osculating) epoch (t0)
//             (4-6)  position at reference epoch (r0)
//             (7-9)  velocity at reference epoch (v0)
//              (10)  heliocentric distance at reference epoch
//              (11)  r0.v0
//              (12)  date (t)
//              (13)  universal eccentric anomaly (psi) of date, approx
//
//     JSTAT   i      status:  0 = OK
//                            -1 = illegal JFORM
//                            -2 = illegal E
//                            -3 = illegal AORQ
//                            -4 = illegal DM
//                            -5 = numerical error
//
//  Called:  sla_UE2PV, sla_PV2UE
//
//  Notes
//
//  1  The "universal" elements are those which define the orbit for the
//     purposes of the method of universal variables (see reference).
//     They consist of the combined mass of the two bodies, an epoch,
//     and the position and velocity vectors (arbitrary reference frame)
//     at that epoch.  The parameter set used here includes also various
//     quantities that can, in fact, be derived from the other
//     information.  This approach is taken to avoiding unnecessary
//     computation and loss of accuracy.  The supplementary quantities
//     are (i) alpha, which is proportional to the total energy of the
//     orbit, (ii) the heliocentric distance at epoch, (iii) the
//     outwards component of the velocity at the given epoch, (iv) an
//     estimate of psi, the "universal eccentric anomaly" at a given
//     date and (v) that date.
//
//  2  The companion routine is sla_UE2PV.  This takes the set of numbers
//     that the present routine outputs and uses them to derive the
//     object's position and velocity.  A single prediction requires one
//     call to the present routine followed by one call to sla_UE2PV;
//     for convenience, the two calls are packaged as the routine
//     sla_PLANEL.  Multiple predictions may be made by again calling the
//     present routine once, but then calling sla_UE2PV multiple times,
//     which is faster than multiple calls to sla_PLANEL.
//
//  3  DATE is the epoch of osculation.  It is in the TT timescale
//     (formerly Ephemeris Time, ET) and is a Modified Julian Date
//     (JD-2400000.5).
//
//  4  The supplied orbital elements are with respect to the J2000
//     ecliptic and equinox.  The position and velocity parameters
//     returned in the array U are with respect to the mean equator and
//     equinox of epoch J2000, and are for the perihelion prior to the
//     specified epoch.
//
//  5  The universal elements returned in the array U are in canonical
//     units (solar masses, AU and canonical days).
//
//  6  Three different element-format options are available:
//
//     Option JFORM=1, suitable for the major planets:
//
//     EPOCH  = epoch of elements (TT MJD)
//     ORBINC = inclination i (radians)
//     ANODE  = longitude of the ascending node, big omega (radians)
//     PERIH  = longitude of perihelion, curly pi (radians)
//     AORQ   = mean distance, a (AU)
//     E      = eccentricity, e (range 0 to <1)
//     AORL   = mean longitude L (radians)
//     DM     = daily motion (radians)
//
//     Option JFORM=2, suitable for minor planets:
//
//     EPOCH  = epoch of elements (TT MJD)
//     ORBINC = inclination i (radians)
//     ANODE  = longitude of the ascending node, big omega (radians)
//     PERIH  = argument of perihelion, little omega (radians)
//     AORQ   = mean distance, a (AU)
//     E      = eccentricity, e (range 0 to <1)
//     AORL   = mean anomaly M (radians)
//
//     Option JFORM=3, suitable for comets:
//
//     EPOCH  = epoch of perihelion (TT MJD)
//     ORBINC = inclination i (radians)
//     ANODE  = longitude of the ascending node, big omega (radians)
//     PERIH  = argument of perihelion, little omega (radians)
//     AORQ   = perihelion distance, q (AU)
//     E      = eccentricity, e (range 0 to 10)
//
//  7  Unused elements (DM for JFORM=2, AORL and DM for JFORM=3) are
//     not accessed.
//
//  8  The algorithm was originally adapted from the EPHSLA program of
//     D.H.P.Jones (private communication, 1996).  The method is based
//     on Stumpff's Universal Variables.
//
//  Reference:  Everhart & Pitkin, Am.J.Phys. 51, 712 (1983).
//
//  Last revision:   8 September 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct el2ue 
{
double U[13];int JSTAT;

  el2ue( const double DATE,const int JFORM,double EPOCH,double ORBINC,double ANODE,double PERIH,double AORQ,double E,double AORL,double DM )
  {
   sla_el2ue_( &DATE,&JFORM,&EPOCH,&ORBINC,&ANODE,&PERIH,&AORQ,&E,&AORL,&DM,U,&JSTAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "U,JSTAT : " << U<<" "<<JSTAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const el2ue& o ) { return s << o.__str__(); }

//     - - - - - -
//      C R 2 A F
//     - - - - - -
//
//  Convert an angle in radians into degrees, arcminutes, arcseconds
//  (single precision)
//
//  Given:
//     NDP       int      number of decimal places of arcseconds
//     ANGLE     real     angle in radians
//
//  Returned:
//     SIGN      char     '+' or '-'
//     IDMSF     int(4)   degrees, arcminutes, arcseconds, fraction
//
//  Notes:
//
//     1)  NDP less than zero is interpreted as zero.
//
//     2)  The largest useful value for NDP is determined by the size of
//         ANGLE, the format of REAL floating-point numbers on the target
//         machine, and the risk of overflowing IDMSF(4).  On some
//         architectures, for ANGLE up to 2pi, the available floating-
//         point precision corresponds roughly to NDP=3.  This is well
//         below the ultimate limit of NDP=9 set by the capacity of a
//         typical 32-bit IDMSF(4).
//
//     3)  The absolute value of ANGLE may exceed 2pi.  In cases where it
//         does not, it is up to the caller to test for and handle the
//         case where ANGLE is very nearly 2pi and rounds up to 360 deg,
//         by testing for IDMSF(1)=360 and setting IDMSF(1-4) to zero.
//
//  Called:  sla_CD2TF
//
//  Last revision:   26 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct cr2af 
{
char SIGN;int IDMSF[4];

  cr2af( const int NDP,const float ANGLE )
  {
   sla_cr2af_( &NDP,&ANGLE,&SIGN,IDMSF );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "SIGN,IDMSF : " << SIGN<<" "<<IDMSF << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const cr2af& o ) { return s << o.__str__(); }

//     - - - - - -
//      E C L E Q
//     - - - - - -
//
//  Transformation from ecliptic coordinates to
//  J2000.0 equatorial coordinates (double precision)
//
//  Given:
//     DL,DB       dp      ecliptic longitude and latitude
//                           (mean of date, IAU 1980 theory, radians)
//     DATE        dp      TDB (loosely ET) as Modified Julian Date
//                                              (JD-2400000.5)
//  Returned:
//     DR,DD       dp      J2000.0 mean RA,Dec (radians)
//
//  Called:
//     sla_DCS2C, sla_ECMAT, sla_DIMXV, sla_PREC, sla_EPJ, sla_DCC2S,
//     sla_DRANRM, sla_DRANGE
//
//  P.T.Wallace   Starlink   March 1986
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct ecleq 
{
double DR;double DD;

  ecleq( const double DL,const double DB,const double DATE )
  {
   sla_ecleq_( &DL,&DB,&DATE,&DR,&DD );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DR,DD : " << DR<<" "<<DD << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const ecleq& o ) { return s << o.__str__(); }

//     - - - - - -
//      M A P P A
//     - - - - - -
//
//  Compute star-independent parameters in preparation for
//  conversions between mean place and geocentric apparent place.
//
//  The parameters produced by this routine are required in the
//  parallax, light deflection, aberration, and precession/nutation
//  parts of the mean/apparent transformations.
//
//  The reference frames and timescales used are post IAU 1976.
//
//  Given:
//     EQ       d      epoch of mean equinox to be used (Julian)
//     DATE     d      TDB (JD-2400000.5)
//
//  Returned:
//     AMPRMS   d(21)  star-independent mean-to-apparent parameters:
//
//       (1)      time interval for proper motion (Julian years)
//       (2-4)    barycentric position of the Earth (AU)
//       (5-7)    heliocentric direction of the Earth (unit vector)
//       (8)      (grav rad Sun)*2/(Sun-Earth distance)
//       (9-11)   ABV: barycentric Earth velocity in units of c
//       (12)     sqrt(1-v**2) where v=modulus(ABV)
//       (13-21)  precession/nutation (3,3) matrix
//
//  References:
//     1984 Astronomical Almanac, pp B39-B41.
//     (also Lederle & Schwan, Astron. Astrophys. 134,
//      1-6, 1984)
//
//  Notes:
//
//  1)  For DATE, the distinction between the required TDB and TT
//      is always negligible.  Moreover, for all but the most
//      critical applications UTC is adequate.
//
//  2)  The vectors AMPRMS(2-4) and AMPRMS(5-7) are referred to
//      the mean equinox and equator of epoch EQ.
//
//  3)  The parameters AMPRMS produced by this routine are used by
//      sla_AMPQK, sla_MAPQK and sla_MAPQKZ.
//
//  4)  The accuracy is sub-milliarcsecond, limited by the
//      precession-nutation model (IAU 1976 precession, Shirai &
//      Fukushima 2001 forced nutation and precession corrections).
//
//  5)  A further limit to the accuracy of routines using the parameter
//      array AMPRMS is imposed by the routine sla_EVP, used here to
//      compute the Earth position and velocity by the methods of
//      Stumpff.  The maximum error in the resulting aberration
//      corrections is about 0.3 milliarcsecond.
//
//  Called:
//     sla_EPJ         MDJ to Julian epoch
//     sla_EVP         earth position & velocity
//     sla_DVN         normalize vector
//     sla_PRENUT      precession/nutation matrix
//
//  P.T.Wallace   Starlink   24 October 2003
//
//  Copyright (C) 2003 Rutherford Appleton Laboratory
//


struct mappa 
{
double AMPRMS[21];

  mappa( const double EQ,const double DATE )
  {
   sla_mappa_( &EQ,&DATE,AMPRMS );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "AMPRMS : " << AMPRMS << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const mappa& o ) { return s << o.__str__(); }

//     - - - - - -
//      C T F 2 D
//     - - - - - -
//
//  Convert hours, minutes, seconds to days (single precision)
//
//  Given:
//     IHOUR       int       hours
//     IMIN        int       minutes
//     SEC         real      seconds
//
//  Returned:
//     DAYS        real      interval in days
//     J           int       status:  0 = OK
//                                    1 = IHOUR outside range 0-23
//                                    2 = IMIN outside range 0-59
//                                    3 = SEC outside range 0-59.999...
//
//  Notes:
//
//  1)  The result is computed even if any of the range checks
//      fail.
//
//  2)  The sign must be dealt with outside this routine.
//
//  P.T.Wallace   Starlink   November 1984
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct ctf2d 
{
float DAYS;int J;

  ctf2d( const int IHOUR,const int IMIN,const float SEC )
  {
   sla_ctf2d_( &IHOUR,&IMIN,&SEC,&DAYS,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DAYS,J : " << DAYS<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const ctf2d& o ) { return s << o.__str__(); }

//     - - - - - -
//      U N P C D
//     - - - - - -
//
//  Remove pincushion/barrel distortion from a distorted [x,y] to give
//  tangent-plane [x,y].
//
//  Given:
//     DISCO    d      pincushion/barrel distortion coefficient
//     X,Y      d      distorted coordinates
//
//  Returned:
//     X,Y      d      tangent-plane coordinates
//
//  Notes:
//
//  1)  The distortion is of the form RP = R*(1+C*R^2), where R is
//      the radial distance from the tangent point, C is the DISCO
//      argument, and RP is the radial distance in the presence of
//      the distortion.
//
//  2)  For pincushion distortion, C is +ve;  for barrel distortion,
//      C is -ve.
//
//  3)  For X,Y in "radians" - units of one projection radius,
//      which in the case of a photograph is the focal length of
//      the camera - the following DISCO values apply:
//
//          Geometry          DISCO
//
//          astrograph         0.0
//          Schmidt           -0.3333
//          AAT PF doublet  +147.069
//          AAT PF triplet  +178.585
//          AAT f/8          +21.20
//          JKT f/8          +13.32
//
//  4)  The present routine is a rigorous inverse of the companion
//      routine sla_PCD.  The expression for RP in Note 1 is rewritten
//      in the form x^3+a*x+b=0 and solved by standard techniques.
//
//  5)  Cases where the cubic has multiple real roots can sometimes
//      occur, corresponding to extreme instances of barrel distortion
//      where up to three different undistorted [X,Y]s all produce the
//      same distorted [X,Y].  However, only one solution is returned,
//      the one that produces the smallest change in [X,Y].
//
//  P.T.Wallace   Starlink   3 September 2000
//
//  Copyright (C) 2000 Rutherford Appleton Laboratory
//


struct unpcd 
{
;

  unpcd( const double DISCO,double X,double Y )
  {
   sla_unpcd_( &DISCO,&X,&Y );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << " : " << "<obj holds not state>" << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const unpcd& o ) { return s << o.__str__(); }

//     - - - - - -
//      C D 2 T F
//     - - - - - -
//
//  Convert an interval in days into hours, minutes, seconds
//
//  (single precision)
//
//  Given:
//     NDP       int      number of decimal places of seconds
//     DAYS      real     interval in days
//
//  Returned:
//     SIGN      char     '+' or '-'
//     IHMSF     int(4)   hours, minutes, seconds, fraction
//
//  Notes:
//
//     1)  NDP less than zero is interpreted as zero.
//
//     2)  The largest useful value for NDP is determined by the size of
//         DAYS, the format of REAL floating-point numbers on the target
//         machine, and the risk of overflowing IHMSF(4).  On some
//         architectures, for DAYS up to 1.0, the available floating-
//         point precision corresponds roughly to NDP=3.  This is well
//         below the ultimate limit of NDP=9 set by the capacity of a
//         typical 32-bit IHMSF(4).
//
//     3)  The absolute value of DAYS may exceed 1.0.  In cases where it
//         does not, it is up to the caller to test for and handle the
//         case where DAYS is very nearly 1.0 and rounds up to 24 hours,
//         by testing for IHMSF(1)=24 and setting IHMSF(1-4) to zero.
//
//  Called:  sla_DD2TF
//
//  Last revision:   26 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct cd2tf 
{
char SIGN;int IHMSF[4];

  cd2tf( const int NDP,const float DAYS )
  {
   sla_cd2tf_( &NDP,&DAYS,&SIGN,IHMSF );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "SIGN,IHMSF : " << SIGN<<" "<<IHMSF << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const cd2tf& o ) { return s << o.__str__(); }

//     - - - -
//      M X M
//     - - - -
//
//  Product of two 3x3 matrices:
//      matrix C  =  matrix A  x  matrix B
//
//  (single precision)
//
//  Given:
//      A      real(3,3)        matrix
//      B      real(3,3)        matrix
//
//  Returned:
//      C      real(3,3)        matrix result
//
//  To comply with the ANSI Fortran 77 standard, A, B and C must
//  be different arrays.  However, the routine is coded so as to
//  work properly on many platforms even if this rule is violated.
//
//  Last revision:   26 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct mxm 
{
float C[3][3];

  mxm( const float A[3][3],const float B[3][3] )
  {
   sla_mxm_( A,B,C );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "C : " << C << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const mxm& o ) { return s << o.__str__(); }

//     - - - - - - -
//      D F L T I N
//     - - - - - - -
//
//  Convert free-format input into double precision floating point
//
//  Given:
//     STRING     c     string containing number to be decoded
//     NSTRT      i     pointer to where decoding is to start
//     DRESLT     d     current value of result
//
//  Returned:
//     NSTRT      i      advanced to next number
//     DRESLT     d      result
//     JFLAG      i      status: -1 = -OK, 0 = +OK, 1 = null, 2 = error
//
//  Notes:
//
//     1     The reason DFLTIN has separate OK status values for +
//           and - is to enable minus zero to be detected.   This is
//           of crucial importance when decoding mixed-radix numbers.
//           For example, an angle expressed as deg, arcmin, arcsec
//           may have a leading minus sign but a zero degrees field.
//
//     2     A TAB is interpreted as a space, and lowercase characters
//           are interpreted as uppercase.
//
//     3     The basic format is the sequence of fields #^.^@#^, where
//           # is a sign character + or -, ^ means a string of decimal
//           digits, and @, which indicates an exponent, means D or E.
//           Various combinations of these fields can be omitted, and
//           embedded blanks are permissible in certain places.
//
//     4     Spaces:
//
//             .  Leading spaces are ignored.
//
//             .  Embedded spaces are allowed only after +, -, D or E,
//                and after the decomal point if the first sequence of
//                digits is absent.
//
//             .  Trailing spaces are ignored;  the first signifies
//                end of decoding and subsequent ones are skipped.
//
//     5     Delimiters:
//
//             .  Any character other than +,-,0-9,.,D,E or space may be
//                used to signal the end of the number and terminate
//                decoding.
//
//             .  Comma is recognized by DFLTIN as a special case;  it
//                is skipped, leaving the pointer on the next character.
//                See 13, below.
//
//     6     Both signs are optional.  The default is +.
//
//     7     The mantissa ^.^ defaults to 1.
//
//     8     The exponent @#^ defaults to D0.
//
//     9     The strings of decimal digits may be of any length.
//
//     10    The decimal point is optional for whole numbers.
//
//     11    A "null result" occurs when the string of characters being
//           decoded does not begin with +,-,0-9,.,D or E, or consists
//           entirely of spaces.  When this condition is detected, JFLAG
//           is set to 1 and DRESLT is left untouched.
//
//     12    NSTRT = 1 for the first character in the string.
//
//     13    On return from DFLTIN, NSTRT is set ready for the next
//           decode - following trailing blanks and any comma.  If a
//           delimiter other than comma is being used, NSTRT must be
//           incremented before the next call to DFLTIN, otherwise
//           all subsequent calls will return a null result.
//
//     14    Errors (JFLAG=2) occur when:
//
//             .  a +, -, D or E is left unsatisfied;  or
//
//             .  the decimal point is present without at least
//                one decimal digit before or after it;  or
//
//             .  an exponent more than 100 has been presented.
//
//     15    When an error has been detected, NSTRT is left
//           pointing to the character following the last
//           one used before the error came to light.  This
//           may be after the point at which a more sophisticated
//           program could have detected the error.  For example,
//           DFLTIN does not detect that '1D999' is unacceptable
//           (on a computer where this is so) until the entire number
//           has been decoded.
//
//     16    Certain highly unlikely combinations of mantissa &
//           exponent can cause arithmetic faults during the
//           decode, in some cases despite the fact that they
//           together could be construed as a valid number.
//
//     17    Decoding is left to right, one pass.
//
//     18    See also FLOTIN and INTIN
//
//  Called:  sla__IDCHF
//
//  P.T.Wallace   Starlink   18 March 1999
//
//  Copyright (C) 1999 Rutherford Appleton Laboratory
//


struct dfltin 
{
int JFLAG;

  dfltin( const char STRING,int NSTRT,double DRESLT )
  {
   sla_dfltin_( &STRING,&NSTRT,&DRESLT,&JFLAG );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "JFLAG : " << JFLAG << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dfltin& o ) { return s << o.__str__(); }

//     - - - - - - -
//      P L A N T U
//     - - - - - - -
//
//  Topocentric apparent RA,Dec of a Solar-System object whose
//  heliocentric universal elements are known.
//
//  Given:
//     DATE      d     TT MJD of observation (JD - 2400000.5)
//     ELONG     d     observer's east longitude (radians)
//     PHI       d     observer's geodetic latitude (radians)
//     U       d(13)   universal elements
//
//               (1)   combined mass (M+m)
//               (2)   total energy of the orbit (alpha)
//               (3)   reference (osculating) epoch (t0)
//             (4-6)   position at reference epoch (r0)
//             (7-9)   velocity at reference epoch (v0)
//              (10)   heliocentric distance at reference epoch
//              (11)   r0.v0
//              (12)   date (t)
//              (13)   universal eccentric anomaly (psi) of date, approx
//
//  Returned:
//     RA,DEC    d     RA, Dec (topocentric apparent, radians)
//     R         d     distance from observer (AU)
//     JSTAT     i     status:  0 = OK
//                             -1 = radius vector zero
//                             -2 = failed to converge
//
//  Called: sla_GMST, sla_DT, sla_EPJ, sla_EPV, sla_UE2PV, sla_PRENUT,
//          sla_DMXV, sla_PVOBS, sla_DCC2S, sla_DRANRM
//
//  Notes:
//
//  1  DATE is the instant for which the prediction is required.  It is
//     in the TT timescale (formerly Ephemeris Time, ET) and is a
//     Modified Julian Date (JD-2400000.5).
//
//  2  The longitude and latitude allow correction for geocentric
//     parallax.  This is usually a small effect, but can become
//     important for near-Earth asteroids.  Geocentric positions can be
//     generated by appropriate use of routines sla_EPV (or sla_EVP) and
//     sla_UE2PV.
//
//  3  The "universal" elements are those which define the orbit for the
//     purposes of the method of universal variables (see reference 2).
//     They consist of the combined mass of the two bodies, an epoch,
//     and the position and velocity vectors (arbitrary reference frame)
//     at that epoch.  The parameter set used here includes also various
//     quantities that can, in fact, be derived from the other
//     information.  This approach is taken to avoiding unnecessary
//     computation and loss of accuracy.  The supplementary quantities
//     are (i) alpha, which is proportional to the total energy of the
//     orbit, (ii) the heliocentric distance at epoch, (iii) the
//     outwards component of the velocity at the given epoch, (iv) an
//     estimate of psi, the "universal eccentric anomaly" at a given
//     date and (v) that date.
//
//  4  The universal elements are with respect to the J2000 equator and
//     equinox.
//
//     1  Sterne, Theodore E., "An Introduction to Celestial Mechanics",
//        Interscience Publishers Inc., 1960.  Section 6.7, p199.
//
//     2  Everhart, E. & Pitkin, E.T., Am.J.Phys. 51, 712, 1983.
//
//  Last revision:   19 February 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct plantu 
{
double RA;double DEC;double R;int JSTAT;

  plantu( const double DATE,const double ELONG,const double PHI,const double U[13] )
  {
   sla_plantu_( &DATE,&ELONG,&PHI,U,&RA,&DEC,&R,&JSTAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RA,DEC,R,JSTAT : " << RA<<" "<<DEC<<" "<<R<<" "<<JSTAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const plantu& o ) { return s << o.__str__(); }

//     - - - -
//      P A V
//     - - - -
//
//  Position angle of one celestial direction with respect to another.
//
//  (single precision)
//
//  Given:
//     V1    r(3)    direction cosines of one point
//     V2    r(3)    direction cosines of the other point
//
//  (The coordinate frames correspond to RA,Dec, Long,Lat etc.)
//
//  The result is the bearing (position angle), in radians, of point
//  V2 with respect to point V1.  It is in the range +/- pi.  The
//  sense is such that if V2 is a small distance east of V1, the
//  bearing is about +pi/2.  Zero is returned if the two points
//  are coincident.
//
//  V1 and V2 do not have to be unit vectors.
//
//  The routine sla_BEAR performs an equivalent function except
//  that the points are specified in the form of spherical
//  coordinates.
//
//  Called:  sla_DPAV
//
//  Last revision:   11 September 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


inline float pav( const float V1[3],const float V2[3] )
{
 return sla_pav_( V1,V2 );
};
//     - - - - -
//      D V X V
//     - - - - -
//
//  Vector product of two 3-vectors  (double precision)
//
//  Given:
//      VA      dp(3)     first vector
//      VB      dp(3)     second vector
//
//  Returned:
//      VC      dp(3)     vector result
//
//  P.T.Wallace   Starlink   March 1986
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct dvxv 
{
double VC[3];

  dvxv( const double VA[3],const double VB[3] )
  {
   sla_dvxv_( VA,VB,VC );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "VC : " << VC << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dvxv& o ) { return s << o.__str__(); }

//     - - - - - -
//      A L T A Z
//     - - - - - -
//
//  Positions, velocities and accelerations for an altazimuth
//  telescope mount.
//
//  (double precision)
//
//  Given:
//     HA      d     hour angle
//     DEC     d     declination
//     PHI     d     observatory latitude
//
//  Returned:
//     AZ      d     azimuth
//     AZD     d        "    velocity
//     AZDD    d        "    acceleration
//     EL      d     elevation
//     ELD     d         "     velocity
//     ELDD    d         "     acceleration
//     PA      d     parallactic angle
//     PAD     d         "      "   velocity
//     PADD    d         "      "   acceleration
//
//  Notes:
//
//  1)  Natural units are used throughout.  HA, DEC, PHI, AZ, EL
//      and ZD are in radians.  The velocities and accelerations
//      assume constant declination and constant rate of change of
//      hour angle (as for tracking a star);  the units of AZD, ELD
//      and PAD are radians per radian of HA, while the units of AZDD,
//      ELDD and PADD are radians per radian of HA squared.  To
//      convert into practical degree- and second-based units:
//
//        angles * 360/2pi -> degrees
//        velocities * (2pi/86400)*(360/2pi) -> degree/sec
//        accelerations * ((2pi/86400)**2)*(360/2pi) -> degree/sec/sec
//
//      Note that the seconds here are sidereal rather than SI.  One
//      sidereal second is about 0.99727 SI seconds.
//
//      The velocity and acceleration factors assume the sidereal
//      tracking case.  Their respective numerical values are (exactly)
//      1/240 and (approximately) 1/3300236.9.
//
//  2)  Azimuth is returned in the range 0-2pi;  north is zero,
//      and east is +pi/2.  Elevation and parallactic angle are
//      returned in the range +/-pi.  Parallactic angle is +ve for
//      a star west of the meridian and is the angle NP-star-zenith.
//
//  3)  The latitude is geodetic as opposed to geocentric.  The
//      hour angle and declination are topocentric.  Refraction and
//      deficiencies in the telescope mounting are ignored.  The
//      purpose of the routine is to give the general form of the
//      quantities.  The details of a real telescope could profoundly
//      change the results, especially close to the zenith.
//
//  4)  No range checking of arguments is carried out.
//
//  5)  In applications which involve many such calculations, rather
//      than calling the present routine it will be more efficient to
//      use inline code, having previously computed fixed terms such
//      as sine and cosine of latitude, and (for tracking a star)
//      sine and cosine of declination.
//
//  This revision:  29 October 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct altaz 
{
double AZ;double AZD;double AZDD;double EL;double ELD;double ELDD;double PA;double PAD;double PADD;

  altaz( const double HA,const double DEC,const double PHI )
  {
   sla_altaz_( &HA,&DEC,&PHI,&AZ,&AZD,&AZDD,&EL,&ELD,&ELDD,&PA,&PAD,&PADD );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "AZ,AZD,AZDD,EL,ELD,ELDD,PA,PAD,PADD : " << AZ<<" "<<AZD<<" "<<AZDD<<" "<<EL<<" "<<ELD<<" "<<ELDD<<" "<<PA<<" "<<PAD<<" "<<PADD << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const altaz& o ) { return s << o.__str__(); }

//     - - - - - -
//      D A V 2 M
//     - - - - - -
//
//  Form the rotation matrix corresponding to a given axial vector.
//  (double precision)
//
//  A rotation matrix describes a rotation about some arbitrary axis,
//  called the Euler axis.  The "axial vector" supplied to this routine
//  has the same direction as the Euler axis, and its magnitude is the
//  amount of rotation in radians.
//
//  Given:
//    AXVEC  d(3)     axial vector (radians)
//
//  Returned:
//    RMAT   d(3,3)   rotation matrix
//
//  If AXVEC is null, the unit matrix is returned.
//
//  The reference frame rotates clockwise as seen looking along
//  the axial vector from the origin.
//
//  Last revision:   26 November 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct dav2m 
{
double RMAT[3][3];

  dav2m( const double AXVEC[3] )
  {
   sla_dav2m_( AXVEC,RMAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RMAT : " << RMAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dav2m& o ) { return s << o.__str__(); }

//     - - - - -
//      D E 2 H
//     - - - - -
//
//  Equatorial to horizon coordinates:  HA,Dec to Az,El
//
//  (double precision)
//
//  Given:
//     HA      d     hour angle
//     DEC     d     declination
//     PHI     d     observatory latitude
//
//  Returned:
//     AZ      d     azimuth
//     EL      d     elevation
//
//  Notes:
//
//  1)  All the arguments are angles in radians.
//
//  2)  Azimuth is returned in the range 0-2pi;  north is zero,
//      and east is +pi/2.  Elevation is returned in the range
//      +/-pi/2.
//
//  3)  The latitude must be geodetic.  In critical applications,
//      corrections for polar motion should be applied.
//
//  4)  In some applications it will be important to specify the
//      correct type of hour angle and declination in order to
//      produce the required type of azimuth and elevation.  In
//      particular, it may be important to distinguish between
//      elevation as affected by refraction, which would
//      require the "observed" HA,Dec, and the elevation
//      in vacuo, which would require the "topocentric" HA,Dec.
//      If the effects of diurnal aberration can be neglected, the
//      "apparent" HA,Dec may be used instead of the topocentric
//      HA,Dec.
//
//  5)  No range checking of arguments is carried out.
//
//  6)  In applications which involve many such calculations, rather
//      than calling the present routine it will be more efficient to
//      use inline code, having previously computed fixed terms such
//      as sine and cosine of latitude, and (for tracking a star)
//      sine and cosine of declination.
//
//  P.T.Wallace   Starlink   9 July 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct de2h 
{
double AZ;double EL;

  de2h( const double HA,const double DEC,const double PHI )
  {
   sla_de2h_( &HA,&DEC,&PHI,&AZ,&EL );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "AZ,EL : " << AZ<<" "<<EL << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const de2h& o ) { return s << o.__str__(); }

//     - - - - - - -
//      A I R M A S
//     - - - - - - -
//
//  Air mass at given zenith distance (double precision)
//
//  Given:
//     ZD     d     Observed zenith distance (radians)
//
//  The result is an estimate of the air mass, in units of that
//  at the zenith.
//
//  Notes:
//
//  1)  The "observed" zenith distance referred to above means "as
//      affected by refraction".
//
//  2)  Uses Hardie's (1962) polynomial fit to Bemporad's data for
//      the relative air mass, X, in units of thickness at the zenith
//      as tabulated by Schoenberg (1929). This is adequate for all
//      normal needs as it is accurate to better than 0.1% up to X =
//      6.8 and better than 1% up to X = 10. Bemporad's tabulated
//      values are unlikely to be trustworthy to such accuracy
//      because of variations in density, pressure and other
//      conditions in the atmosphere from those assumed in his work.
//
//  3)  The sign of the ZD is ignored.
//
//  4)  At zenith distances greater than about ZD = 87 degrees the
//      air mass is held constant to avoid arithmetic overflows.
//
//  References:
//     Hardie, R.H., 1962, in "Astronomical Techniques"
//        ed. W.A. Hiltner, University of Chicago Press, p180.
//     Schoenberg, E., 1929, Hdb. d. Ap.,
//        Berlin, Julius Springer, 2, 268.
//
//  Original code by P.W.Hill, St Andrews
//
//  P.T.Wallace   Starlink   18 March 1999
//
//  Copyright (C) 1999 Rutherford Appleton Laboratory
//


inline double airmas( const double ZD )
{
 return sla_airmas_( &ZD );
};
//     - - - - -
//      M O O N
//     - - - - -
//
//  Approximate geocentric position and velocity of the Moon
//  (single precision).
//
//  Given:
//     IY       i       year
//     ID       i       day in year (1 = Jan 1st)
//     FD       r       fraction of day
//
//  Returned:
//     PV       r(6)    Moon position & velocity vector
//
//  Notes:
//
//  1  The date and time is TDB (loosely ET) in a Julian calendar
//     which has been aligned to the ordinary Gregorian
//     calendar for the interval 1900 March 1 to 2100 February 28.
//     The year and day can be obtained by calling sla_CALYD or
//     sla_CLYD.
//
//  2  The Moon 6-vector is Moon centre relative to Earth centre,
//     mean equator and equinox of date.  Position part, PV(1-3),
//     is in AU;  velocity part, PV(4-6), is in AU/sec.
//
//  3  The position is accurate to better than 0.5 arcminute
//     in direction and 1000 km in distance.  The velocity
//     is accurate to better than 0.5"/hour in direction and
//     4 m/s in distance.  (RMS figures with respect to JPL DE200
//     for the interval 1960-2025 are 14 arcsec and 0.2 arcsec/hour in
//     longitude, 9 arcsec and 0.2 arcsec/hour in latitude, 350 km and
//     2 m/s in distance.)  Note that the distance accuracy is
//     comparatively poor because this routine is principally intended
//     for computing topocentric direction.
//
//  4  This routine is only a partial implementation of the original
//     Meeus algorithm (reference below), which offers 4 times the
//     accuracy in direction and 30 times the accuracy in distance
//     when fully implemented (as it is in sla_DMOON).
//
//  Reference:
//     Meeus, l'Astronomie, June 1984, p348.
//
//  Called:  sla_CS2C6
//
//  P.T.Wallace   Starlink   8 December 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct moon 
{
float PV[6];

  moon( const int IY,const int ID,const float FD )
  {
   sla_moon_( &IY,&ID,&FD,PV );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "PV : " << PV << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const moon& o ) { return s << o.__str__(); }

//     - - - - -
//      D V D V
//     - - - - -
//
//  Scalar product of two 3-vectors  (double precision)
//
//  Given:
//      VA      dp(3)     first vector
//      VB      dp(3)     second vector
//
//  The result is the scalar product VA.VB (double precision)
//
//  P.T.Wallace   Starlink   November 1984
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline double dvdv( const double VA[3],const double VB[3] )
{
 return sla_dvdv_( VA,VB );
};
//     - - - - - -
//      D D 2 T F
//     - - - - - -
//
//  Convert an interval in days into hours, minutes, seconds
//  (double precision)
//
//  Given:
//     NDP      i      number of decimal places of seconds
//     DAYS     d      interval in days
//
//  Returned:
//     SIGN     c      '+' or '-'
//     IHMSF    i(4)   hours, minutes, seconds, fraction
//
//  Notes:
//
//     1)  NDP less than zero is interpreted as zero.
//
//     2)  The largest useful value for NDP is determined by the size
//         of DAYS, the format of DOUBLE PRECISION floating-point numbers
//         on the target machine, and the risk of overflowing IHMSF(4).
//         On some architectures, for DAYS up to 1D0, the available
//         floating-point precision corresponds roughly to NDP=12.
//         However, the practical limit is NDP=9, set by the capacity of
//         a typical 32-bit IHMSF(4).
//
//     3)  The absolute value of DAYS may exceed 1D0.  In cases where it
//         does not, it is up to the caller to test for and handle the
//         case where DAYS is very nearly 1D0 and rounds up to 24 hours,
//         by testing for IHMSF(1)=24 and setting IHMSF(1-4) to zero.
//
//  Last revision:   26 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct dd2tf 
{
char SIGN;int IHMSF[4];

  dd2tf( const int NDP,const double DAYS )
  {
   sla_dd2tf_( &NDP,&DAYS,&SIGN,IHMSF );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "SIGN,IHMSF : " << SIGN<<" "<<IHMSF << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dd2tf& o ) { return s << o.__str__(); }

//     - - - - - -
//      G A L E Q
//     - - - - - -
//
//  Transformation from IAU 1958 galactic coordinates to
//  J2000.0 equatorial coordinates (double precision)
//
//  Given:
//     DL,DB       dp       galactic longitude and latitude L2,B2
//
//  Returned:
//     DR,DD       dp       J2000.0 RA,Dec
//
//  (all arguments are radians)
//
//  Called:
//     sla_DCS2C, sla_DIMXV, sla_DCC2S, sla_DRANRM, sla_DRANGE
//
//  Note:
//     The equatorial coordinates are J2000.0.  Use the routine
//     sla_GE50 if conversion to B1950.0 'FK4' coordinates is
//     required.
//
//  Reference:
//     Blaauw et al, Mon.Not.R.Astron.Soc.,121,123 (1960)
//
//  P.T.Wallace   Starlink   21 September 1998
//
//  Copyright (C) 1998 Rutherford Appleton Laboratory
//


struct galeq 
{
double DR;double DD;

  galeq( const double DL,const double DB )
  {
   sla_galeq_( &DL,&DB,&DR,&DD );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DR,DD : " << DR<<" "<<DD << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const galeq& o ) { return s << o.__str__(); }

//     - - - -
//      O A P
//     - - - -
//
//  Observed to apparent place.
//
//  Given:
//     TYPE   c*(*)  type of coordinates - 'R', 'H' or 'A' (see below)
//     OB1    d      observed Az, HA or RA (radians; Az is N=0,E=90)
//     OB2    d      observed ZD or Dec (radians)
//     DATE   d      UTC date/time (modified Julian Date, JD-2400000.5)
//     DUT    d      delta UT:  UT1-UTC (UTC seconds)
//     ELONGM d      mean longitude of the observer (radians, east +ve)
//     PHIM   d      mean geodetic latitude of the observer (radians)
//     HM     d      observer's height above sea level (metres)
//     XP     d      polar motion x-coordinate (radians)
//     YP     d      polar motion y-coordinate (radians)
//     TDK    d      local ambient temperature (K; std=273.15D0)
//     PMB    d      local atmospheric pressure (mb; std=1013.25D0)
//     RH     d      local relative humidity (in the range 0D0-1D0)
//     WL     d      effective wavelength (micron, e.g. 0.55D0)
//     TLR    d      tropospheric lapse rate (K/metre, e.g. 0.0065D0)
//
//  Returned:
//     RAP    d      geocentric apparent right ascension
//     DAP    d      geocentric apparent declination
//
//  Notes:
//
//  1)  Only the first character of the TYPE argument is significant.
//      'R' or 'r' indicates that OBS1 and OBS2 are the observed right
//      ascension and declination;  'H' or 'h' indicates that they are
//      hour angle (west +ve) and declination;  anything else ('A' or
//      'a' is recommended) indicates that OBS1 and OBS2 are azimuth
//      (north zero, east 90 deg) and zenith distance.  (Zenith
//      distance is used rather than elevation in order to reflect the
//      fact that no allowance is made for depression of the horizon.)
//
//  2)  The accuracy of the result is limited by the corrections for
//      refraction.  Providing the meteorological parameters are
//      known accurately and there are no gross local effects, the
//      predicted apparent RA,Dec should be within about 0.1 arcsec
//      for a zenith distance of less than 70 degrees.  Even at a
//      topocentric zenith distance of 90 degrees, the accuracy in
//      elevation should be better than 1 arcmin;  useful results
//      are available for a further 3 degrees, beyond which the
//      sla_REFRO routine returns a fixed value of the refraction.
//      The complementary routines sla_AOP (or sla_AOPQK) and sla_OAP
//      (or sla_OAPQK) are self-consistent to better than 1 micro-
//      arcsecond all over the celestial sphere.
//
//  3)  It is advisable to take great care with units, as even
//      unlikely values of the input parameters are accepted and
//      processed in accordance with the models used.
//
//  4)  "Observed" Az,El means the position that would be seen by a
//      perfect theodolite located at the observer.  This is
//      related to the observed HA,Dec via the standard rotation, using
//      the geodetic latitude (corrected for polar motion), while the
//      observed HA and RA are related simply through the local
//      apparent ST.  "Observed" RA,Dec or HA,Dec thus means the
//      position that would be seen by a perfect equatorial located
//      at the observer and with its polar axis aligned to the
//      Earth's axis of rotation (n.b. not to the refracted pole).
//      By removing from the observed place the effects of
//      atmospheric refraction and diurnal aberration, the
//      geocentric apparent RA,Dec is obtained.
//
//  5)  Frequently, mean rather than apparent RA,Dec will be required,
//      in which case further transformations will be necessary.  The
//      sla_AMP etc routines will convert the apparent RA,Dec produced
//      by the present routine into an "FK5" (J2000) mean place, by
//      allowing for the Sun's gravitational lens effect, annual
//      aberration, nutation and precession.  Should "FK4" (1950)
//      coordinates be needed, the routines sla_FK524 etc will also
//      need to be applied.
//
//  6)  To convert to apparent RA,Dec the coordinates read from a
//      real telescope, corrections would have to be applied for
//      encoder zero points, gear and encoder errors, tube flexure,
//      the position of the rotator axis and the pointing axis
//      relative to it, non-perpendicularity between the mounting
//      axes, and finally for the tilt of the azimuth or polar axis
//      of the mounting (with appropriate corrections for mount
//      flexures).  Some telescopes would, of course, exhibit other
//      properties which would need to be accounted for at the
//      appropriate point in the sequence.
//
//  7)  This routine takes time to execute, due mainly to the rigorous
//      integration used to evaluate the refraction.  For processing
//      multiple stars for one location and time, call sla_AOPPA once
//      followed by one call per star to sla_OAPQK.  Where a range of
//      times within a limited period of a few hours is involved, and the
//      highest precision is not required, call sla_AOPPA once, followed
//      by a call to sla_AOPPAT each time the time changes, followed by
//      one call per star to sla_OAPQK.
//
//  8)  The DATE argument is UTC expressed as an MJD.  This is, strictly
//      speaking, wrong, because of leap seconds.  However, as long as
//      the delta UT and the UTC are consistent there are no
//      difficulties, except during a leap second.  In this case, the
//      start of the 61st second of the final minute should begin a new
//      MJD day and the old pre-leap delta UT should continue to be used.
//      As the 61st second completes, the MJD should revert to the start
//      of the day as, simultaneously, the delta UTC changes by one
//      second to its post-leap new value.
//
//  9)  The delta UT (UT1-UTC) is tabulated in IERS circulars and
//      elsewhere.  It increases by exactly one second at the end of
//      each UTC leap second, introduced in order to keep delta UT
//      within +/- 0.9 seconds.
//
//  10) IMPORTANT -- TAKE CARE WITH THE LONGITUDE SIGN CONVENTION.
//      The longitude required by the present routine is east-positive,
//      in accordance with geographical convention (and right-handed).
//      In particular, note that the longitudes returned by the
//      sla_OBS routine are west-positive, following astronomical
//      usage, and must be reversed in sign before use in the present
//      routine.
//
//  11) The polar coordinates XP,YP can be obtained from IERS
//      circulars and equivalent publications.  The maximum amplitude
//      is about 0.3 arcseconds.  If XP,YP values are unavailable,
//      use XP=YP=0D0.  See page B60 of the 1988 Astronomical Almanac
//      for a definition of the two angles.
//
//  12) The height above sea level of the observing station, HM,
//      can be obtained from the Astronomical Almanac (Section J
//      in the 1988 edition), or via the routine sla_OBS.  If P,
//      the pressure in millibars, is available, an adequate
//      estimate of HM can be obtained from the expression
//
//             HM ~ -29.3D0*TSL*LOG(P/1013.25D0).
//
//      where TSL is the approximate sea-level air temperature in K
//      (see Astrophysical Quantities, C.W.Allen, 3rd edition,
//      section 52).  Similarly, if the pressure P is not known,
//      it can be estimated from the height of the observing
//      station, HM, as follows:
//
//             P ~ 1013.25D0*EXP(-HM/(29.3D0*TSL)).
//
//      Note, however, that the refraction is nearly proportional to the
//      pressure and that an accurate P value is important for precise
//      work.
//
//  13) The azimuths etc. used by the present routine are with respect
//      to the celestial pole.  Corrections from the terrestrial pole
//      can be computed using sla_POLMO.
//
//  Called:  sla_AOPPA, sla_OAPQK
//
//  Last revision:   2 December 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct oap 
{
double RAP;double DAP;

  oap( const string& TYPE,const double OB1,const double OB2,const double DATE,const double DUT,const double ELONGM,const double PHIM,const double HM,const double XP,const double YP,const double TDK,const double PMB,const double RH,const double WL,const double TLR )
  {
   sla_oap_( TYPE.c_str(),_pointable<int>(TYPE.length()),&OB1,&OB2,&DATE,&DUT,&ELONGM,&PHIM,&HM,&XP,&YP,&TDK,&PMB,&RH,&WL,&TLR,&RAP,&DAP );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RAP,DAP : " << RAP<<" "<<DAP << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const oap& o ) { return s << o.__str__(); }

//     - - - - - - -
//      N U T C 8 0
//     - - - - - - -
//
//  Nutation:  longitude & obliquity components and mean obliquity,
//  using the IAU 1980 theory (double precision)
//
//  Given:
//     DATE        d     TDB (loosely ET) as Modified Julian Date
//                                            (JD-2400000.5)
//  Returned:
//     DPSI,DEPS   d     nutation in longitude,obliquity
//     EPS0        d     mean obliquity
//
//  Called:  sla_DRANGE
//
//  Notes:
//
//  1  Earth attitude predictions made by combining the present nutation
//     model with IAU 1976 precession are accurate to 0.35 arcsec over
//     the interval 1900-2100.  (The accuracy is much better near the
//     middle of the interval.)
//
//  2  The sla_NUTC routine is the equivalent of the present routine
//     but using the Shirai & Fukushima 2001 forced nutation theory
//     (SF2001).  The newer theory is more accurate than IAU 1980,
//     within 1 mas (with respect to the ICRF) for a few decades around
//     2000.  The improvement is mainly because of the corrections to the
//     IAU 1976 precession that the SF2001 theory includes.
//
//  References:
//     Final report of the IAU Working Group on Nutation,
//      chairman P.K.Seidelmann, 1980.
//     Kaplan,G.H., 1981, USNO circular no. 163, pA3-6.
//
//  P.T.Wallace   Starlink   7 October 2001
//
//  Copyright (C) 2001 Rutherford Appleton Laboratory
//


struct nutc80 
{
double DPSI;double DEPS;double EPS0;

  nutc80( const double DATE )
  {
   sla_nutc80_( &DATE,&DPSI,&DEPS,&EPS0 );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DPSI,DEPS,EPS0 : " << DPSI<<" "<<DEPS<<" "<<EPS0 << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const nutc80& o ) { return s << o.__str__(); }

//     - - - - - - -
//      P L A N E L
//     - - - - - - -
//
//  Heliocentric position and velocity of a planet, asteroid or comet,
//  starting from orbital elements.
//
//  Given:
//     DATE     d     date, Modified Julian Date (JD - 2400000.5, Note 1)
//     JFORM    i     choice of element set (1-3; Note 3)
//     EPOCH    d     epoch of elements (TT MJD, Note 4)
//     ORBINC   d     inclination (radians)
//     ANODE    d     longitude of the ascending node (radians)
//     PERIH    d     longitude or argument of perihelion (radians)
//     AORQ     d     mean distance or perihelion distance (AU)
//     E        d     eccentricity
//     AORL     d     mean anomaly or longitude (radians, JFORM=1,2 only)
//     DM       d     daily motion (radians, JFORM=1 only)
//
//  Returned:
//     PV       d(6)  heliocentric x,y,z,xdot,ydot,zdot of date,
//                                     J2000 equatorial triad (AU,AU/s)
//     JSTAT    i     status:  0 = OK
//                            -1 = illegal JFORM
//                            -2 = illegal E
//                            -3 = illegal AORQ
//                            -4 = illegal DM
//                            -5 = numerical error
//
//  Called:  sla_EL2UE, sla_UE2PV
//
//  Notes
//
//  1  DATE is the instant for which the prediction is required.  It is
//     in the TT timescale (formerly Ephemeris Time, ET) and is a
//     Modified Julian Date (JD-2400000.5).
//
//  2  The elements are with respect to the J2000 ecliptic and equinox.
//
//  3  A choice of three different element-set options is available:
//
//     Option JFORM = 1, suitable for the major planets:
//
//       EPOCH  = epoch of elements (TT MJD)
//       ORBINC = inclination i (radians)
//       ANODE  = longitude of the ascending node, big omega (radians)
//       PERIH  = longitude of perihelion, curly pi (radians)
//       AORQ   = mean distance, a (AU)
//       E      = eccentricity, e (range 0 to <1)
//       AORL   = mean longitude L (radians)
//       DM     = daily motion (radians)
//
//     Option JFORM = 2, suitable for minor planets:
//
//       EPOCH  = epoch of elements (TT MJD)
//       ORBINC = inclination i (radians)
//       ANODE  = longitude of the ascending node, big omega (radians)
//       PERIH  = argument of perihelion, little omega (radians)
//       AORQ   = mean distance, a (AU)
//       E      = eccentricity, e (range 0 to <1)
//       AORL   = mean anomaly M (radians)
//
//     Option JFORM = 3, suitable for comets:
//
//       EPOCH  = epoch of elements and perihelion (TT MJD)
//       ORBINC = inclination i (radians)
//       ANODE  = longitude of the ascending node, big omega (radians)
//       PERIH  = argument of perihelion, little omega (radians)
//       AORQ   = perihelion distance, q (AU)
//       E      = eccentricity, e (range 0 to 10)
//
//     Unused arguments (DM for JFORM=2, AORL and DM for JFORM=3) are not
//     accessed.
//
//  4  Each of the three element sets defines an unperturbed heliocentric
//     orbit.  For a given epoch of observation, the position of the body
//     in its orbit can be predicted from these elements, which are
//     called "osculating elements", using standard two-body analytical
//     solutions.  However, due to planetary perturbations, a given set
//     of osculating elements remains usable for only as long as the
//     unperturbed orbit that it describes is an adequate approximation
//     to reality.  Attached to such a set of elements is a date called
//     the "osculating epoch", at which the elements are, momentarily,
//     a perfect representation of the instantaneous position and
//     velocity of the body.
//
//     Therefore, for any given problem there are up to three different
//     epochs in play, and it is vital to distinguish clearly between
//     them:
//
//     . The epoch of observation:  the moment in time for which the
//       position of the body is to be predicted.
//
//     . The epoch defining the position of the body:  the moment in time
//       at which, in the absence of purturbations, the specified
//       position (mean longitude, mean anomaly, or perihelion) is
//       reached.
//
//     . The osculating epoch:  the moment in time at which the given
//       elements are correct.
//
//     For the major-planet and minor-planet cases it is usual to make
//     the epoch that defines the position of the body the same as the
//     epoch of osculation.  Thus, only two different epochs are
//     involved:  the epoch of the elements and the epoch of observation.
//
//     For comets, the epoch of perihelion fixes the position in the
//     orbit and in general a different epoch of osculation will be
//     chosen.  Thus, all three types of epoch are involved.
//
//     For the present routine:
//
//     . The epoch of observation is the argument DATE.
//
//     . The epoch defining the position of the body is the argument
//       EPOCH.
//
//     . The osculating epoch is not used and is assumed to be close
//       enough to the epoch of observation to deliver adequate accuracy.
//       If not, a preliminary call to sla_PERTEL may be used to update
//       the element-set (and its associated osculating epoch) by
//       applying planetary perturbations.
//
//  5  The reference frame for the result is with respect to the mean
//     equator and equinox of epoch J2000.
//
//  6  The algorithm was originally adapted from the EPHSLA program of
//     D.H.P.Jones (private communication, 1996).  The method is based
//     on Stumpff's Universal Variables.
//
//  Reference:  Everhart, E. & Pitkin, E.T., Am.J.Phys. 51, 712, 1983.
//
//  P.T.Wallace   Starlink   31 December 2002
//
//  Copyright (C) 2002 Rutherford Appleton Laboratory
//


struct planel 
{
double PV[6];int JSTAT;

  planel( const double DATE,const int JFORM,const double EPOCH,const double ORBINC,const double ANODE,const double PERIH,const double AORQ,const double E,const double AORL,const double DM )
  {
   sla_planel_( &DATE,&JFORM,&EPOCH,&ORBINC,&ANODE,&PERIH,&AORQ,&E,&AORL,&DM,PV,&JSTAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "PV,JSTAT : " << PV<<" "<<JSTAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const planel& o ) { return s << o.__str__(); }

//     - - - - - -
//      H 2 F K 5
//     - - - - - -
//
//  Transform Hipparcos star data into the FK5 (J2000) system.
//
//  (double precision)
//
//  This routine transforms Hipparcos star positions and proper
//  motions into FK5 J2000.
//
//  Given (all Hipparcos, epoch J2000):
//     RH        d      RA (radians)
//     DH        d      Dec (radians)
//     DRH       d      proper motion in RA (dRA/dt, rad/Jyear)
//     DDH       d      proper motion in Dec (dDec/dt, rad/Jyear)
//
//  Returned (all FK5, equinox J2000, epoch J2000):
//     R5        d      RA (radians)
//     D5        d      Dec (radians)
//     DR5       d      proper motion in RA (dRA/dt, rad/Jyear)
//     DD5       d      proper motion in Dec (dDec/dt, rad/Jyear)
//
//  Called:  sla_DS2C6, sla_DAV2M, sla_DMXV, sla_DIMXV, sla_DVXV,
//           sla_DC62S, sla_DRANRM
//
//  Notes:
//
//  1)  The proper motions in RA are dRA/dt rather than
//      cos(Dec)*dRA/dt, and are per year rather than per century.
//
//  2)  The FK5 to Hipparcos transformation consists of a pure
//      rotation and spin;  zonal errors in the FK5 catalogue are
//      not taken into account.
//
//  3)  The published orientation and spin components are interpreted
//      as "axial vectors".  An axial vector points at the pole of the
//      rotation and its length is the amount of rotation in radians.
//
//  4)  See also sla_FK52H, sla_FK5HZ, sla_HFK5Z.
//
//  Reference:
//
//     M.Feissel & F.Mignard, Astron. Astrophys. 331, L33-L36 (1998).
//
//  P.T.Wallace   Starlink   22 June 1999
//
//  Copyright (C) 1999 Rutherford Appleton Laboratory
//


struct h2fk5 
{
double R5;double D5;double DR5;double DD5;

  h2fk5( const double RH,const double DH,const double DRH,const double DDH )
  {
   sla_h2fk5_( &RH,&DH,&DRH,&DDH,&R5,&D5,&DR5,&DD5 );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "R5,D5,DR5,DD5 : " << R5<<" "<<D5<<" "<<DR5<<" "<<DD5 << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const h2fk5& o ) { return s << o.__str__(); }

//     - - - - -
//      D M X M
//     - - - - -
//
//  Product of two 3x3 matrices:
//
//      matrix C  =  matrix A  x  matrix B
//
//  (double precision)
//
//  Given:
//      A      dp(3,3)        matrix
//      B      dp(3,3)        matrix
//
//  Returned:
//      C      dp(3,3)        matrix result
//
//  To comply with the ANSI Fortran 77 standard, A, B and C must
//  be different arrays.  However, the routine is coded so as to
//  work properly on many platforms even if this rule is violated.
//
//  Last revision:   26 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct dmxm 
{
double C[3][3];

  dmxm( const double A[3][3],const double B[3][3] )
  {
   sla_dmxm_( A,B,C );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "C : " << C << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dmxm& o ) { return s << o.__str__(); }

//     - - -
//      V N
//     - - -
//
//  Normalizes a 3-vector also giving the modulus (single precision)
//
//  Given:
//     V       real(3)      vector
//
//  Returned:
//     UV      real(3)      unit vector in direction of V
//     VM      real         modulus of V
//
//  If the modulus of V is zero, UV is set to zero as well
//
//  P.T.Wallace   Starlink   23 November 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct vn 
{
float UV[3];float VM;

  vn( const float V[3] )
  {
   sla_vn_( V,UV,&VM );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "UV,VM : " << UV<<" "<<VM << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const vn& o ) { return s << o.__str__(); }

//     - - - - -
//      C L Y D
//     - - - - -
//
//  Gregorian calendar to year and day in year (in a Julian calendar
//  aligned to the 20th/21st century Gregorian calendar).
//
//  Given:
//     IY,IM,ID   i    year, month, day in Gregorian calendar
//
//  Returned:
//     NY         i    year (re-aligned Julian calendar)
//     ND         i    day in year (1 = January 1st)
//     JSTAT      i    status:
//                       0 = OK
//                       1 = bad year (before -4711)
//                       2 = bad month
//                       3 = bad day (but conversion performed)
//
//  Notes:
//
//  1  This routine exists to support the low-precision routines
//     sla_EARTH, sla_MOON and sla_ECOR.
//
//  2  Between 1900 March 1 and 2100 February 28 it returns answers
//     which are consistent with the ordinary Gregorian calendar.
//     Outside this range there will be a discrepancy which increases
//     by one day for every non-leap century year.
//
//  3  The essence of the algorithm is first to express the Gregorian
//     date as a Julian Day Number and then to convert this back to
//     a Julian calendar date, with day-in-year instead of month and
//     day.  See 12.92-1 and 12.95-1 in the reference.
//
//  Reference:  Explanatory Supplement to the Astronomical Almanac,
//              ed P.K.Seidelmann, University Science Books (1992),
//              p604-606.
//
//  P.T.Wallace   Starlink   26 November 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct clyd 
{
int NY;int ND;int JSTAT;

  clyd( const int IY,const int IM,const int ID )
  {
   sla_clyd_( &IY,&IM,&ID,&NY,&ND,&JSTAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "NY,ND,JSTAT : " << NY<<" "<<ND<<" "<<JSTAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const clyd& o ) { return s << o.__str__(); }

//     - - - - -
//      M 2 A V
//     - - - - -
//
//  From a rotation matrix, determine the corresponding axial vector
//  (single precision)
//
//  A rotation matrix describes a rotation about some arbitrary axis,
//  called the Euler axis.  The "axial vector" returned by this routine
//  has the same direction as the Euler axis, and its magnitude is the
//  amount of rotation in radians.  (The magnitude and direction can be
//  separated by means of the routine sla_VN.)
//
//  Given:
//    RMAT   r(3,3)   rotation matrix
//
//  Returned:
//    AXVEC  r(3)     axial vector (radians)
//
//  The reference frame rotates clockwise as seen looking along
//  the axial vector from the origin.
//
//  If RMAT is null, so is the result.
//
//  Last revision:   26 November 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct m2av 
{
float AXVEC[3];

  m2av( const float RMAT[3][3] )
  {
   sla_m2av_( RMAT,AXVEC );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "AXVEC : " << AXVEC << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const m2av& o ) { return s << o.__str__(); }

//     - - - - - -
//      D R 2 T F
//     - - - - - -
//
//  Convert an angle in radians to hours, minutes, seconds
//  (double precision)
//
//  Given:
//     NDP      i      number of decimal places of seconds
//     ANGLE    d      angle in radians
//
//  Returned:
//     SIGN     c      '+' or '-'
//     IHMSF    i(4)   hours, minutes, seconds, fraction
//
//  Notes:
//
//     1)  NDP less than zero is interpreted as zero.
//
//     2)  The largest useful value for NDP is determined by the size
//         of ANGLE, the format of DOUBLE PRECISION floating-point
//         numbers on the target machine, and the risk of overflowing
//         IHMSF(4).  On some architectures, for ANGLE up to 2pi, the
//         available floating-point precision corresponds roughly to
//         NDP=12.  However, the practical limit is NDP=9, set by the
//         capacity of a typical 32-bit IHMSF(4).
//
//     3)  The absolute value of ANGLE may exceed 2pi.  In cases where it
//         does not, it is up to the caller to test for and handle the
//         case where ANGLE is very nearly 2pi and rounds up to 24 hours,
//         by testing for IHMSF(1)=24 and setting IHMSF(1-4) to zero.
//
//  Called:  sla_DD2TF
//
//  Last revision:   26 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct dr2tf 
{
char SIGN;int IHMSF[4];

  dr2tf( const int NDP,const double ANGLE )
  {
   sla_dr2tf_( &NDP,&ANGLE,&SIGN,IHMSF );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "SIGN,IHMSF : " << SIGN<<" "<<IHMSF << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dr2tf& o ) { return s << o.__str__(); }

//     - - - - -
//      A T M S
//     - - - - -
//
//  Internal routine used by REFRO
//
//  Refractive index and derivative with respect to height for the
//  stratosphere.
//
//  Given:
//    RT      d    height of tropopause from centre of the Earth (metre)
//    TT      d    temperature at the tropopause (K)
//    DNT     d    refractive index at the tropopause
//    GAMAL   d    constant of the atmospheric model = G*MD/R
//    R       d    current distance from the centre of the Earth (metre)
//
//  Returned:
//    DN      d    refractive index at R
//    RDNDR   d    R * rate the refractive index is changing at R
//
//  Last revision:   26 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct _atms 
{
double DN;double RDNDR;

  _atms( const double RT,const double TT,const double DNT,const double GAMAL,const double R )
  {
   sla__atms_( &RT,&TT,&DNT,&GAMAL,&R,&DN,&RDNDR );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DN,RDNDR : " << DN<<" "<<RDNDR << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const _atms& o ) { return s << o.__str__(); }

//     - - -
//      P A
//     - - -
//
//  HA, Dec to Parallactic Angle (double precision)
//
//  Given:
//     HA     d     hour angle in radians (geocentric apparent)
//     DEC    d     declination in radians (geocentric apparent)
//     PHI    d     observatory latitude in radians (geodetic)
//
//  The result is in the range -pi to +pi
//
//  Notes:
//
//  1)  The parallactic angle at a point in the sky is the position
//      angle of the vertical, i.e. the angle between the direction to
//      the pole and to the zenith.  In precise applications care must
//      be taken only to use geocentric apparent HA,Dec and to consider
//      separately the effects of atmospheric refraction and telescope
//      mount errors.
//
//  2)  At the pole a zero result is returned.
//
//  P.T.Wallace   Starlink   16 August 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline double pa( const double HA,const double DEC,const double PHI )
{
 return sla_pa_( &HA,&DEC,&PHI );
};
//     - - - - - -
//      D C M P F
//     - - - - - -
//
//  Decompose an [X,Y] linear fit into its constituent parameters:
//  zero points, scales, nonperpendicularity and orientation.
//
//  Given:
//     COEFFS  d(6)      transformation coefficients (see note)
//
//  Returned:
//     XZ       d        x zero point
//     YZ       d        y zero point
//     XS       d        x scale
//     YS       d        y scale
//     PERP     d        nonperpendicularity (radians)
//     ORIENT   d        orientation (radians)
//
//  Called:  sla_DRANGE
//
//  The model relates two sets of [X,Y] coordinates as follows.
//  Naming the elements of COEFFS:
//
//     COEFFS(1) = A
//     COEFFS(2) = B
//     COEFFS(3) = C
//     COEFFS(4) = D
//     COEFFS(5) = E
//     COEFFS(6) = F
//
//  the model transforms coordinates [X1,Y1] into coordinates
//  [X2,Y2] as follows:
//
//     X2 = A + B*X1 + C*Y1
//     Y2 = D + E*X1 + F*Y1
//
//  The transformation can be decomposed into four steps:
//
//     1)  Zero points:
//
//             x' = XZ + X1
//             y' = YZ + Y1
//
//     2)  Scales:
//
//             x'' = XS*x'
//             y'' = YS*y'
//
//     3)  Nonperpendicularity:
//
//             x''' = cos(PERP/2)*x'' + sin(PERP/2)*y''
//             y''' = sin(PERP/2)*x'' + cos(PERP/2)*y''
//
//     4)  Orientation:
//
//             X2 = cos(ORIENT)*x''' + sin(ORIENT)*y'''
//             Y2 =-sin(ORIENT)*y''' + cos(ORIENT)*y'''
//
//  See also sla_FITXY, sla_PXY, sla_INVF, sla_XY2XY
//
//  P.T.Wallace   Starlink   19 December 2001
//
//  Copyright (C) 2001 Rutherford Appleton Laboratory
//


struct dcmpf 
{
double XZ;double YZ;double XS;double YS;double PERP;double ORIENT;

  dcmpf( const double COEFFS[6] )
  {
   sla_dcmpf_( COEFFS,&XZ,&YZ,&XS,&YS,&PERP,&ORIENT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "XZ,YZ,XS,YS,PERP,ORIENT : " << XZ<<" "<<YZ<<" "<<XS<<" "<<YS<<" "<<PERP<<" "<<ORIENT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dcmpf& o ) { return s << o.__str__(); }

//     - - - - - -
//      D B E A R
//     - - - - - -
//
//  Bearing (position angle) of one point on a sphere relative to another
//  (double precision)
//
//  Given:
//     A1,B1    d    spherical coordinates of one point
//     A2,B2    d    spherical coordinates of the other point
//
//  (The spherical coordinates are RA,Dec, Long,Lat etc, in radians.)
//
//  The result is the bearing (position angle), in radians, of point
//  A2,B2 as seen from point A1,B1.  It is in the range +/- pi.  If
//  A2,B2 is due east of A1,B1 the bearing is +pi/2.  Zero is returned
//  if the two points are coincident.
//
//  P.T.Wallace   Starlink   23 March 1991
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline double dbear( const double A1,const double B1,const double A2,const double B2 )
{
 return sla_dbear_( &A1,&B1,&A2,&B2 );
};
//     - - - - -
//      A F I N
//     - - - - -
//
//  Sexagesimal character string to angle (single precision)
//
//  Given:
//     STRING  c*(*)   string containing deg, arcmin, arcsec fields
//     IPTR      i     pointer to start of decode (1st = 1)
//
//  Returned:
//     IPTR      i     advanced past the decoded angle
//     A         r     angle in radians
//     J         i     status:  0 = OK
//                             +1 = default, A unchanged
//                             -1 = bad degrees      )
//                             -2 = bad arcminutes   )  (note 3)
//                             -3 = bad arcseconds   )
//
//  Example:
//
//    argument    before                           after
//
//    STRING      '-57 17 44.806  12 34 56.7'      unchanged
//    IPTR        1                                16 (points to 12...)
//    A           ?                                -1.00000
//    J           ?                                0
//
//    A further call to sla_AFIN, without adjustment of IPTR, will
//    decode the second angle, 12deg 34min 56.7sec.
//
//  Notes:
//
//     1)  The first three "fields" in STRING are degrees, arcminutes,
//         arcseconds, separated by spaces or commas.  The degrees field
//         may be signed, but not the others.  The decoding is carried
//         out by the DFLTIN routine and is free-format.
//
//     2)  Successive fields may be absent, defaulting to zero.  For
//         zero status, the only combinations allowed are degrees alone,
//         degrees and arcminutes, and all three fields present.  If all
//         three fields are omitted, a status of +1 is returned and A is
//         unchanged.  In all other cases A is changed.
//
//     3)  Range checking:
//
//           The degrees field is not range checked.  However, it is
//           expected to be integral unless the other two fields are
//           absent.
//
//           The arcminutes field is expected to be 0-59, and integral if
//           the arcseconds field is present.  If the arcseconds field
//           is absent, the arcminutes is expected to be 0-59.9999...
//
//           The arcseconds field is expected to be 0-59.9999...
//
//     4)  Decoding continues even when a check has failed.  Under these
//         circumstances the field takes the supplied value, defaulting
//         to zero, and the result A is computed and returned.
//
//     5)  Further fields after the three expected ones are not treated
//         as an error.  The pointer IPTR is left in the correct state
//         for further decoding with the present routine or with DFLTIN
//         etc.  See the example, above.
//
//     6)  If STRING contains hours, minutes, seconds instead of degrees
//         etc, or if the required units are turns (or days) instead of
//         radians, the result A should be multiplied as follows:
//
//           for        to obtain    multiply
//           STRING     A in         A by
//
//           d ' "      radians      1       =  1.0
//           d ' "      turns        1/2pi   =  0.1591549430918953358
//           h m s      radians      15      =  15.0
//           h m s      days         15/2pi  =  2.3873241463784300365
//
//  Called:  sla_DAFIN
//
//  P.T.Wallace   Starlink   13 September 1990
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct afin 
{
float A;int J;

  afin( const string& STRING,int IPTR )
  {
   sla_afin_( STRING.c_str(),_pointable<int>(STRING.length()),&IPTR,&A,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "A,J : " << A<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const afin& o ) { return s << o.__str__(); }

//     - - - - - -
//      D S 2 T P
//     - - - - - -
//
//  Projection of spherical coordinates onto tangent plane:
//  "gnomonic" projection - "standard coordinates" (double precision)
//
//  Given:
//     RA,DEC      dp   spherical coordinates of point to be projected
//     RAZ,DECZ    dp   spherical coordinates of tangent point
//
//  Returned:
//     XI,ETA      dp   rectangular coordinates on tangent plane
//     J           int  status:   0 = OK, star on tangent plane
//                                1 = error, star too far from axis
//                                2 = error, antistar on tangent plane
//                                3 = error, antistar too far from axis
//
//  P.T.Wallace   Starlink   18 July 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct ds2tp 
{
double XI;double ETA;int J;

  ds2tp( const double RA,const double DEC,const double RAZ,const double DECZ )
  {
   sla_ds2tp_( &RA,&DEC,&RAZ,&DECZ,&XI,&ETA,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "XI,ETA,J : " << XI<<" "<<ETA<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const ds2tp& o ) { return s << o.__str__(); }

//     - - - - - -
//      D T P 2 S
//     - - - - - -
//
//  Transform tangent plane coordinates into spherical
//  (double precision)
//
//  Given:
//     XI,ETA      dp   tangent plane rectangular coordinates
//     RAZ,DECZ    dp   spherical coordinates of tangent point
//
//  Returned:
//     RA,DEC      dp   spherical coordinates (0-2pi,+/-pi/2)
//
//  Called:        sla_DRANRM
//
//  P.T.Wallace   Starlink   24 July 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct dtp2s 
{
double RA;double DEC;

  dtp2s( const double XI,const double ETA,const double RAZ,const double DECZ )
  {
   sla_dtp2s_( &XI,&ETA,&RAZ,&DECZ,&RA,&DEC );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RA,DEC : " << RA<<" "<<DEC << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dtp2s& o ) { return s << o.__str__(); }

//     - - - - - -
//      F K 5 2 H
//     - - - - - -
//
//  Transform FK5 (J2000) star data into the Hipparcos frame.
//
//  (double precision)
//
//  This routine transforms FK5 star positions and proper motions
//  into the frame of the Hipparcos catalogue.
//
//  Given (all FK5, equinox J2000, epoch J2000):
//     R5        d      RA (radians)
//     D5        d      Dec (radians)
//     DR5       d      proper motion in RA (dRA/dt, rad/Jyear)
//     DD5       d      proper motion in Dec (dDec/dt, rad/Jyear)
//
//  Returned (all Hipparcos, epoch J2000):
//     RH        d      RA (radians)
//     DH        d      Dec (radians)
//     DRH       d      proper motion in RA (dRA/dt, rad/Jyear)
//     DDH       d      proper motion in Dec (dDec/dt, rad/Jyear)
//
//  Called:  sla_DS2C6, sla_DAV2M, sla_DMXV, sla_DVXV, sla_DC62S,
//           sla_DRANRM
//
//  Notes:
//
//  1)  The proper motions in RA are dRA/dt rather than
//      cos(Dec)*dRA/dt, and are per year rather than per century.
//
//  2)  The FK5 to Hipparcos transformation consists of a pure
//      rotation and spin;  zonal errors in the FK5 catalogue are
//      not taken into account.
//
//  3)  The published orientation and spin components are interpreted
//      as "axial vectors".  An axial vector points at the pole of the
//      rotation and its length is the amount of rotation in radians.
//
//  4)  See also sla_H2FK5, sla_FK5HZ, sla_HFK5Z.
//
//  Reference:
//
//     M.Feissel & F.Mignard, Astron. Astrophys. 331, L33-L36 (1998).
//
//  P.T.Wallace   Starlink   22 June 1999
//
//  Copyright (C) 1999 Rutherford Appleton Laboratory
//


struct fk52h 
{
double RH;double DH;double DRH;double DDH;

  fk52h( const double R5,const double D5,const double DR5,const double DD5 )
  {
   sla_fk52h_( &R5,&D5,&DR5,&DD5,&RH,&DH,&DRH,&DDH );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RH,DH,DRH,DDH : " << RH<<" "<<DH<<" "<<DRH<<" "<<DDH << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const fk52h& o ) { return s << o.__str__(); }

//     - - - - - -
//      M A P Q K
//     - - - - - -
//
//  Quick mean to apparent place:  transform a star RA,Dec from
//  mean place to geocentric apparent place, given the
//  star-independent parameters.
//
//  Use of this routine is appropriate when efficiency is important
//  and where many star positions, all referred to the same equator
//  and equinox, are to be transformed for one epoch.  The
//  star-independent parameters can be obtained by calling the
//  sla_MAPPA routine.
//
//  If the parallax and proper motions are zero the sla_MAPQKZ
//  routine can be used instead.
//
//  The reference frames and timescales used are post IAU 1976.
//
//  Given:
//     RM,DM    d      mean RA,Dec (rad)
//     PR,PD    d      proper motions:  RA,Dec changes per Julian year
//     PX       d      parallax (arcsec)
//     RV       d      radial velocity (km/sec, +ve if receding)
//
//     AMPRMS   d(21)  star-independent mean-to-apparent parameters:
//
//       (1)      time interval for proper motion (Julian years)
//       (2-4)    barycentric position of the Earth (AU)
//       (5-7)    heliocentric direction of the Earth (unit vector)
//       (8)      (grav rad Sun)*2/(Sun-Earth distance)
//       (9-11)   barycentric Earth velocity in units of c
//       (12)     sqrt(1-v**2) where v=modulus(ABV)
//       (13-21)  precession/nutation (3,3) matrix
//
//  Returned:
//     RA,DA    d      apparent RA,Dec (rad)
//
//  References:
//     1984 Astronomical Almanac, pp B39-B41.
//     (also Lederle & Schwan, Astron. Astrophys. 134,
//      1-6, 1984)
//
//  Notes:
//
//  1)  The vectors AMPRMS(2-4) and AMPRMS(5-7) are referred to
//      the mean equinox and equator of epoch EQ.
//
//  2)  Strictly speaking, the routine is not valid for solar-system
//      sources, though the error will usually be extremely small.
//      However, to prevent gross errors in the case where the
//      position of the Sun is specified, the gravitational
//      deflection term is restrained within about 920 arcsec of the
//      centre of the Sun's disc.  The term has a maximum value of
//      about 1.85 arcsec at this radius, and decreases to zero as
//      the centre of the disc is approached.
//
//  Called:
//     sla_DCS2C       spherical to Cartesian
//     sla_DVDV        dot product
//     sla_DMXV        matrix x vector
//     sla_DCC2S       Cartesian to spherical
//     sla_DRANRM      normalize angle 0-2Pi
//
//  P.T.Wallace   Starlink   15 January 2000
//
//  Copyright (C) 2000 Rutherford Appleton Laboratory
//


struct mapqk 
{
double RA;double DA;

  mapqk( const double RM,const double DM,const double PR,const double PD,const double PX,const double RV,const double AMPRMS[21] )
  {
   sla_mapqk_( &RM,&DM,&PR,&PD,&PX,&RV,AMPRMS,&RA,&DA );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RA,DA : " << RA<<" "<<DA << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const mapqk& o ) { return s << o.__str__(); }

//     - - - - - - -
//      R V L S R D
//     - - - - - - -
//
//  Velocity component in a given direction due to the Sun's motion
//  with respect to the dynamical Local Standard of Rest.
//
//  (single precision)
//
//  Given:
//     R2000,D2000   r    J2000.0 mean RA,Dec (radians)
//
//  Result:
//     Component of "peculiar" solar motion in direction R2000,D2000 (km/s)
//
//  Sign convention:
//     The result is +ve when the Sun is receding from the given point on
//     the sky.
//
//  Note:  The Local Standard of Rest used here is the "dynamical" LSR,
//         a point in the vicinity of the Sun which is in a circular
//         orbit around the Galactic centre.  The Sun's motion with
//         respect to the dynamical LSR is called the "peculiar" solar
//         motion.
//
//         There is another type of LSR, called a "kinematical" LSR.  A
//         kinematical LSR is the mean standard of rest of specified star
//         catalogues or stellar populations, and several slightly
//         different kinematical LSRs are in use.  The Sun's motion with
//         respect to an agreed kinematical LSR is known as the "standard"
//         solar motion.  To obtain a radial velocity correction with
//         respect to an adopted kinematical LSR use the routine sla_RVLSRK.
//
//  Reference:  Delhaye (1965), in "Stars and Stellar Systems", vol 5,
//              p73.
//
//  Called:
//     sla_CS2C, sla_VDV
//
//  P.T.Wallace   Starlink   9 March 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline float rvlsrd( const float R2000,const float D2000 )
{
 return sla_rvlsrd_( &R2000,&D2000 );
};
//     - - -
//      D T
//     - - -
//
//  Estimate the offset between dynamical time and Universal Time
//  for a given historical epoch.
//
//  Given:
//     EPOCH       d        (Julian) epoch (e.g. 1850D0)
//
//  The result is a rough estimate of ET-UT (after 1984, TT-UT) at
//  the given epoch, in seconds.
//
//  Notes:
//
//  1  Depending on the epoch, one of three parabolic approximations
//     is used:
//
//      before 979    Stephenson & Morrison's 390 BC to AD 948 model
//      979 to 1708   Stephenson & Morrison's 948 to 1600 model
//      after 1708    McCarthy & Babcock's post-1650 model
//
//     The breakpoints are chosen to ensure continuity:  they occur
//     at places where the adjacent models give the same answer as
//     each other.
//
//  2  The accuracy is modest, with errors of up to 20 sec during
//     the interval since 1650, rising to perhaps 30 min by 1000 BC.
//     Comparatively accurate values from AD 1600 are tabulated in
//     the Astronomical Almanac (see section K8 of the 1995 AA).
//
//  3  The use of double-precision for both argument and result is
//     purely for compatibility with other SLALIB time routines.
//
//  4  The models used are based on a lunar tidal acceleration value
//     of -26.00 arcsec per century.
//
//  Reference:  Explanatory Supplement to the Astronomical Almanac,
//              ed P.K.Seidelmann, University Science Books (1992),
//              section 2.553, p83.  This contains references to
//              the Stephenson & Morrison and McCarthy & Babcock
//              papers.
//
//  P.T.Wallace   Starlink   1 March 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline double dt( const double EPOCH )
{
 return sla_dt_( &EPOCH );
};
//     - - - - - -
//      C T F 2 R
//     - - - - - -
//
//  Convert hours, minutes, seconds to radians (single precision)
//
//  Given:
//     IHOUR       int       hours
//     IMIN        int       minutes
//     SEC         real      seconds
//
//  Returned:
//     RAD         real      angle in radians
//     J           int       status:  0 = OK
//                                    1 = IHOUR outside range 0-23
//                                    2 = IMIN outside range 0-59
//                                    3 = SEC outside range 0-59.999...
//
//  Called:
//     sla_CTF2D
//
//  Notes:
//
//  1)  The result is computed even if any of the range checks
//      fail.
//
//  2)  The sign must be dealt with outside this routine.
//
//  P.T.Wallace   Starlink   November 1984
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct ctf2r 
{
float RAD;int J;

  ctf2r( const int IHOUR,const int IMIN,const float SEC )
  {
   sla_ctf2r_( &IHOUR,&IMIN,&SEC,&RAD,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RAD,J : " << RAD<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const ctf2r& o ) { return s << o.__str__(); }

//     - - - - -
//      D P A V
//     - - - - -
//
//  Position angle of one celestial direction with respect to another.
//
//  (double precision)
//
//  Given:
//     V1    d(3)    direction cosines of one point
//     V2    d(3)    direction cosines of the other point
//
//  (The coordinate frames correspond to RA,Dec, Long,Lat etc.)
//
//  The result is the bearing (position angle), in radians, of point
//  V2 with respect to point V1.  It is in the range +/- pi.  The
//  sense is such that if V2 is a small distance east of V1, the
//  bearing is about +pi/2.  Zero is returned if the two points
//  are coincident.
//
//  V1 and V2 need not be unit vectors.
//
//  The routine sla_DBEAR performs an equivalent function except
//  that the points are specified in the form of spherical
//  coordinates.
//
//  Last revision:   16 March 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


inline double dpav( const double V1[3],const double V2[3] )
{
 return sla_dpav_( V1,V2 );
};
//     - - - - - - -
//      P E R T U E
//     - - - - - - -
//
//  Update the universal elements of an asteroid or comet by applying
//  planetary perturbations.
//
//  Given:
//     DATE     d       final epoch (TT MJD) for the updated elements
//
//  Given and returned:
//     U        d(13)   universal elements (updated in place)
//
//                (1)   combined mass (M+m)
//                (2)   total energy of the orbit (alpha)
//                (3)   reference (osculating) epoch (t0)
//              (4-6)   position at reference epoch (r0)
//              (7-9)   velocity at reference epoch (v0)
//               (10)   heliocentric distance at reference epoch
//               (11)   r0.v0
//               (12)   date (t)
//               (13)   universal eccentric anomaly (psi) of date, approx
//
//  Returned:
//     JSTAT    i       status:
//                          +102 = warning, distant epoch
//                          +101 = warning, large timespan ( > 100 years)
//                     +1 to +10 = coincident with major planet (Note 5)
//                             0 = OK
//                            -1 = numerical error
//
//  Called:  sla_EPJ, sla_PLANET, sla_PV2UE, sla_UE2PV, sla_EPV,
//           sla_PREC, sla_DMOON, sla_DMXV
//
//  Notes:
//
//  1  The "universal" elements are those which define the orbit for the
//     purposes of the method of universal variables (see reference 2).
//     They consist of the combined mass of the two bodies, an epoch,
//     and the position and velocity vectors (arbitrary reference frame)
//     at that epoch.  The parameter set used here includes also various
//     quantities that can, in fact, be derived from the other
//     information.  This approach is taken to avoiding unnecessary
//     computation and loss of accuracy.  The supplementary quantities
//     are (i) alpha, which is proportional to the total energy of the
//     orbit, (ii) the heliocentric distance at epoch, (iii) the
//     outwards component of the velocity at the given epoch, (iv) an
//     estimate of psi, the "universal eccentric anomaly" at a given
//     date and (v) that date.
//
//  2  The universal elements are with respect to the J2000 equator and
//     equinox.
//
//  3  The epochs DATE, U(3) and U(12) are all Modified Julian Dates
//     (JD-2400000.5).
//
//  4  The algorithm is a simplified form of Encke's method.  It takes as
//     a basis the unperturbed motion of the body, and numerically
//     integrates the perturbing accelerations from the major planets.
//     The expression used is essentially Sterne's 6.7-2 (reference 1).
//     Everhart and Pitkin (reference 2) suggest rectifying the orbit at
//     each integration step by propagating the new perturbed position
//     and velocity as the new universal variables.  In the present
//     routine the orbit is rectified less frequently than this, in order
//     to gain a slight speed advantage.  However, the rectification is
//     done directly in terms of position and velocity, as suggested by
//     Everhart and Pitkin, bypassing the use of conventional orbital
//     elements.
//
//     The f(q) part of the full Encke method is not used.  The purpose
//     of this part is to avoid subtracting two nearly equal quantities
//     when calculating the "indirect member", which takes account of the
//     small change in the Sun's attraction due to the slightly displaced
//     position of the perturbed body.  A simpler, direct calculation in
//     double precision proves to be faster and not significantly less
//     accurate.
//
//     Apart from employing a variable timestep, and occasionally
//     "rectifying the orbit" to keep the indirect member small, the
//     integration is done in a fairly straightforward way.  The
//     acceleration estimated for the middle of the timestep is assumed
//     to apply throughout that timestep;  it is also used in the
//     extrapolation of the perturbations to the middle of the next
//     timestep, to predict the new disturbed position.  There is no
//     iteration within a timestep.
//
//     Measures are taken to reach a compromise between execution time
//     and accuracy.  The starting-point is the goal of achieving
//     arcsecond accuracy for ordinary minor planets over a ten-year
//     timespan.  This goal dictates how large the timesteps can be,
//     which in turn dictates how frequently the unperturbed motion has
//     to be recalculated from the osculating elements.
//
//     Within predetermined limits, the timestep for the numerical
//     integration is varied in length in inverse proportion to the
//     magnitude of the net acceleration on the body from the major
//     planets.
//
//     The numerical integration requires estimates of the major-planet
//     motions.  Approximate positions for the major planets (Pluto
//     alone is omitted) are obtained from the routine sla_PLANET.  Two
//     levels of interpolation are used, to enhance speed without
//     significantly degrading accuracy.  At a low frequency, the routine
//     sla_PLANET is called to generate updated position+velocity "state
//     vectors".  The only task remaining to be carried out at the full
//     frequency (i.e. at each integration step) is to use the state
//     vectors to extrapolate the planetary positions.  In place of a
//     strictly linear extrapolation, some allowance is made for the
//     curvature of the orbit by scaling back the radius vector as the
//     linear extrapolation goes off at a tangent.
//
//     Various other approximations are made.  For example, perturbations
//     by Pluto and the minor planets are neglected and relativistic
//     effects are not taken into account.
//
//     In the interests of simplicity, the background calculations for
//     the major planets are carried out en masse.  The mean elements and
//     state vectors for all the planets are refreshed at the same time,
//     without regard for orbit curvature, mass or proximity.
//
//     The Earth-Moon system is treated as a single body when the body is
//     distant but as separate bodies when closer to the EMB than the
//     parameter RNE, which incurs a time penalty but improves accuracy
//     for near-Earth objects.
//
//  5  This routine is not intended to be used for major planets.
//     However, if major-planet elements are supplied, sensible results
//     will, in fact, be produced.  This happens because the routine
//     checks the separation between the body and each of the planets and
//     interprets a suspiciously small value (0.001 AU) as an attempt to
//     apply the routine to the planet concerned.  If this condition is
//     detected, the contribution from that planet is ignored, and the
//     status is set to the planet number (1-10 = Mercury, Venus, EMB,
//     Mars, Jupiter, Saturn, Uranus, Neptune, Earth, Moon) as a warning.
//
//  References:
//
//     1  Sterne, Theodore E., "An Introduction to Celestial Mechanics",
//        Interscience Publishers Inc., 1960.  Section 6.7, p199.
//
//     2  Everhart, E. & Pitkin, E.T., Am.J.Phys. 51, 712, 1983.
//
//  Last revision:   27 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct pertue 
{
int JSTAT;

  pertue( const double DATE,const double U[13] )
  {
   sla_pertue_( &DATE,U,&JSTAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "JSTAT : " << JSTAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const pertue& o ) { return s << o.__str__(); }

//     - - - -
//      E P J
//     - - - -
//
//  Conversion of Modified Julian Date to Julian Epoch (double precision)
//
//  Given:
//     DATE     dp       Modified Julian Date (JD - 2400000.5)
//
//  The result is the Julian Epoch.
//
//  Reference:
//     Lieske,J.H., 1979. Astron.Astrophys.,73,282.
//
//  P.T.Wallace   Starlink   February 1984
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline double epj( const double DATE )
{
 return sla_epj_( &DATE );
};
//     - - - - - - -
//      A T M D S P
//     - - - - - - -
//
//  Apply atmospheric-dispersion adjustments to refraction coefficients.
//
//  Given:
//     TDK       d       ambient temperature, K
//     PMB       d       ambient pressure, millibars
//     RH        d       ambient relative humidity, 0-1
//     WL1       d       reference wavelength, micrometre (0.4D0 recommended)
//     A1        d       refraction coefficient A for wavelength WL1 (radians)
//     B1        d       refraction coefficient B for wavelength WL1 (radians)
//     WL2       d       wavelength for which adjusted A,B required
//
//  Returned:
//     A2        d       refraction coefficient A for wavelength WL2 (radians)
//     B2        d       refraction coefficient B for wavelength WL2 (radians)
//
//  Notes:
//
//  1  To use this routine, first call sla_REFCO specifying WL1 as the
//     wavelength.  This yields refraction coefficients A1,B1, correct
//     for that wavelength.  Subsequently, calls to sla_ATMDSP specifying
//     different wavelengths will produce new, slightly adjusted
//     refraction coefficients which apply to the specified wavelength.
//
//  2  Most of the atmospheric dispersion happens between 0.7 micrometre
//     and the UV atmospheric cutoff, and the effect increases strongly
//     towards the UV end.  For this reason a blue reference wavelength
//     is recommended, for example 0.4 micrometres.
//
//  3  The accuracy, for this set of conditions:
//
//        height above sea level    2000 m
//                      latitude    29 deg
//                      pressure    793 mb
//                   temperature    17 degC
//                      humidity    50%
//                    lapse rate    0.0065 degC/m
//          reference wavelength    0.4 micrometre
//                star elevation    15 deg
//
//     is about 2.5 mas RMS between 0.3 and 1.0 micrometres, and stays
//     within 4 mas for the whole range longward of 0.3 micrometres
//     (compared with a total dispersion from 0.3 to 20.0 micrometres
//     of about 11 arcsec).  These errors are typical for ordinary
//     conditions and the given elevation;  in extreme conditions values
//     a few times this size may occur, while at higher elevations the
//     errors become much smaller.
//
//  4  If either wavelength exceeds 100 micrometres, the radio case
//     is assumed and the returned refraction coefficients are the
//     same as the given ones.  Note that radio refraction coefficients
//     cannot be turned into optical values using this routine, nor
//     vice versa.
//
//  5  The algorithm consists of calculation of the refractivity of the
//     air at the observer for the two wavelengths, using the methods
//     of the sla_REFRO routine, and then scaling of the two refraction
//     coefficients according to classical refraction theory.  This
//     amounts to scaling the A coefficient in proportion to (n-1) and
//     the B coefficient almost in the same ratio (see R.M.Green,
//     "Spherical Astronomy", Cambridge University Press, 1985).
//
//  Last revision   2 December 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct atmdsp 
{
double A2;double B2;

  atmdsp( const double TDK,const double PMB,const double RH,const double WL1,const double A1,const double B1,const double WL2 )
  {
   sla_atmdsp_( &TDK,&PMB,&RH,&WL1,&A1,&B1,&WL2,&A2,&B2 );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "A2,B2 : " << A2<<" "<<B2 << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const atmdsp& o ) { return s << o.__str__(); }

//     - - - - - -
//      P R E B N
//     - - - - - -
//
//  Generate the matrix of precession between two epochs,
//  using the old, pre-IAU1976, Bessel-Newcomb model, using
//  Kinoshita's formulation (double precision)
//
//  Given:
//     BEP0    dp         beginning Besselian epoch
//     BEP1    dp         ending Besselian epoch
//
//  Returned:
//     RMATP  dp(3,3)    precession matrix
//
//  The matrix is in the sense   V(BEP1)  =  RMATP * V(BEP0)
//
//  Reference:
//     Kinoshita, H. (1975) 'Formulas for precession', SAO Special
//     Report No. 364, Smithsonian Institution Astrophysical
//     Observatory, Cambridge, Massachusetts.
//
//  Called:  sla_DEULER
//
//  P.T.Wallace   Starlink   23 August 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct prebn 
{
double RMATP[3][3];

  prebn( const double BEP0,const double BEP1 )
  {
   sla_prebn_( &BEP0,&BEP1,RMATP );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RMATP : " << RMATP << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const prebn& o ) { return s << o.__str__(); }

//     - - - - -
//      D E 2 H
//     - - - - -
//
//  Horizon to equatorial coordinates:  Az,El to HA,Dec
//
//  (single precision)
//
//  Given:
//     AZ      r     azimuth
//     EL      r     elevation
//     PHI     r     observatory latitude
//
//  Returned:
//     HA      r     hour angle
//     DEC     r     declination
//
//  Notes:
//
//  1)  All the arguments are angles in radians.
//
//  2)  The sign convention for azimuth is north zero, east +pi/2.
//
//  3)  HA is returned in the range +/-pi.  Declination is returned
//      in the range +/-pi/2.
//
//  4)  The latitude is (in principle) geodetic.  In critical
//      applications, corrections for polar motion should be applied.
//
//  5)  In some applications it will be important to specify the
//      correct type of elevation in order to produce the required
//      type of HA,Dec.  In particular, it may be important to
//      distinguish between the elevation as affected by refraction,
//      which will yield the "observed" HA,Dec, and the elevation
//      in vacuo, which will yield the "topocentric" HA,Dec.  If the
//      effects of diurnal aberration can be neglected, the
//      topocentric HA,Dec may be used as an approximation to the
//      "apparent" HA,Dec.
//
//  6)  No range checking of arguments is done.
//
//  7)  In applications which involve many such calculations, rather
//      than calling the present routine it will be more efficient to
//      use inline code, having previously computed fixed terms such
//      as sine and cosine of latitude.
//
//  Last revision:   11 September 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct h2e 
{
float HA;float DEC;

  h2e( const float AZ,const float EL,const float PHI )
  {
   sla_h2e_( &AZ,&EL,&PHI,&HA,&DEC );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "HA,DEC : " << HA<<" "<<DEC << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const h2e& o ) { return s << o.__str__(); }

//     - - - -
//      R C C
//     - - - -
//
//  Relativistic clock correction:  the difference between proper time at
//  a point on the surface of the Earth and coordinate time in the Solar
//  System barycentric space-time frame of reference.
//
//  The proper time is terrestrial time, TT;  the coordinate time is an
//  implementation of barycentric dynamical time, TDB.
//
//  Given:
//    TDB      d     TDB (MJD: JD-2400000.5)
//    UT1      d     universal time (fraction of one day)
//    WL       d     clock longitude (radians west)
//    U        d     clock distance from Earth spin axis (km)
//    V        d     clock distance north of Earth equatorial plane (km)
//
//  Returned:
//    The clock correction, TDB-TT, in seconds:
//
//    .  TDB is coordinate time in the solar system barycentre frame
//       of reference, in units chosen to eliminate the scale difference
//       with respect to terrestrial time.
//
//    .  TT is the proper time for clocks at mean sea level on the
//       Earth.
//
//  Notes:
//
//  1  The argument TDB is, strictly, the barycentric coordinate time;
//     however, the terrestrial time TT can in practice be used without
//     any significant loss of accuracy.
//
//  2  The result returned by sla_RCC comprises a main (annual)
//     sinusoidal term of amplitude approximately 0.00166 seconds, plus
//     planetary and lunar terms up to about 20 microseconds, and diurnal
//     terms up to 2 microseconds.  The variation arises from the
//     transverse Doppler effect and the gravitational red-shift as the
//     observer varies in speed and moves through different gravitational
//     potentials.
//
//  3  The geocentric model is that of Fairhead & Bretagnon (1990), in
//     its full form.  It was supplied by Fairhead (private
//     communication) as a FORTRAN subroutine.  The original Fairhead
//     routine used explicit formulae, in such large numbers that
//     problems were experienced with certain compilers (Microsoft
//     Fortran on PC aborted with stack overflow, Convex compiled
//     successfully but extremely slowly).  The present implementation is
//     a complete recoding, with the original Fairhead coefficients held
//     in a table.  To optimise arithmetic precision, the terms are
//     accumulated in reverse order, smallest first.  A number of other
//     coding changes were made, in order to match the calling sequence
//     of previous versions of the present routine, and to comply with
//     Starlink programming standards.  The numerical results compared
//     with those from the Fairhead form are essentially unaffected by
//     the changes, the differences being at the 10^-20 sec level.
//
//  4  The topocentric part of the model is from Moyer (1981) and
//     Murray (1983).  It is an approximation to the expression
//     ( v / c ) . ( r / c ), where v is the barycentric velocity of
//     the Earth, r is the geocentric position of the observer and
//     c is the speed of light.
//
//  5  During the interval 1950-2050, the absolute accuracy of is better
//     than +/- 3 nanoseconds relative to direct numerical integrations
//     using the JPL DE200/LE200 solar system ephemeris.
//
//  6  The IAU definition of TDB was that it must differ from TT only by
//     periodic terms.  Though practical, this is an imprecise definition
//     which ignores the existence of very long-period and secular
//     effects in the dynamics of the solar system.  As a consequence,
//     different implementations of TDB will, in general, differ in zero-
//     point and will drift linearly relative to one other.
//
//  7  TDB was, in principle, superseded by new coordinate timescales
//     which the IAU introduced in 1991:  geocentric coordinate time,
//     TCG, and barycentric coordinate time, TCB.  However, sla_RCC
//     can be used to implement the periodic part of TCB-TCG.
//
//  References:
//
//  1  Fairhead, L., & Bretagnon, P., Astron.Astrophys., 229, 240-247
//     (1990).
//
//  2  Moyer, T.D., Cel.Mech., 23, 33 (1981).
//
//  3  Murray, C.A., Vectorial Astrometry, Adam Hilger (1983).
//
//  4  Seidelmann, P.K. et al, Explanatory Supplement to the
//     Astronomical Almanac, Chapter 2, University Science Books
//     (1992).
//
//  5  Simon J.L., Bretagnon P., Chapront J., Chapront-Touze M.,
//     Francou G. & Laskar J., Astron.Astrophys., 282, 663-683 (1994).
//
//  P.T.Wallace   Starlink   7 May 2000
//
//  Copyright (C) 2000 Rutherford Appleton Laboratory
//


inline double rcc( const double TDB,const double UT1,const double WL,const double U,const double V )
{
 return sla_rcc_( &TDB,&UT1,&WL,&U,&V );
};
//     - - - - - -
//      U E 2 E L
//     - - - - - -
//
//  Transform universal elements into conventional heliocentric
//  osculating elements.
//
//  Given:
//     U         d(13)  universal orbital elements (Note 1)
//
//                 (1)  combined mass (M+m)
//                 (2)  total energy of the orbit (alpha)
//                 (3)  reference (osculating) epoch (t0)
//               (4-6)  position at reference epoch (r0)
//               (7-9)  velocity at reference epoch (v0)
//                (10)  heliocentric distance at reference epoch
//                (11)  r0.v0
//                (12)  date (t)
//                (13)  universal eccentric anomaly (psi) of date, approx
//
//     JFORMR    i      requested element set (1-3; Note 3)
//
//  Returned:
//     JFORM     d      element set actually returned (1-3; Note 4)
//     EPOCH     d      epoch of elements (TT MJD)
//     ORBINC    d      inclination (radians)
//     ANODE     d      longitude of the ascending node (radians)
//     PERIH     d      longitude or argument of perihelion (radians)
//     AORQ      d      mean distance or perihelion distance (AU)
//     E         d      eccentricity
//     AORL      d      mean anomaly or longitude (radians, JFORM=1,2 only)
//     DM        d      daily motion (radians, JFORM=1 only)
//     JSTAT     i      status:  0 = OK
//                              -1 = illegal combined mass
//                              -2 = illegal JFORMR
//                              -3 = position/velocity out of range
//
//  Notes
//
//  1  The "universal" elements are those which define the orbit for the
//     purposes of the method of universal variables (see reference 2).
//     They consist of the combined mass of the two bodies, an epoch,
//     and the position and velocity vectors (arbitrary reference frame)
//     at that epoch.  The parameter set used here includes also various
//     quantities that can, in fact, be derived from the other
//     information.  This approach is taken to avoiding unnecessary
//     computation and loss of accuracy.  The supplementary quantities
//     are (i) alpha, which is proportional to the total energy of the
//     orbit, (ii) the heliocentric distance at epoch, (iii) the
//     outwards component of the velocity at the given epoch, (iv) an
//     estimate of psi, the "universal eccentric anomaly" at a given
//     date and (v) that date.
//
//  2  The universal elements are with respect to the mean equator and
//     equinox of epoch J2000.  The orbital elements produced are with
//     respect to the J2000 ecliptic and mean equinox.
//
//  3  Three different element-format options are supported:
//
//     Option JFORM=1, suitable for the major planets:
//
//     EPOCH  = epoch of elements (TT MJD)
//     ORBINC = inclination i (radians)
//     ANODE  = longitude of the ascending node, big omega (radians)
//     PERIH  = longitude of perihelion, curly pi (radians)
//     AORQ   = mean distance, a (AU)
//     E      = eccentricity, e
//     AORL   = mean longitude L (radians)
//     DM     = daily motion (radians)
//
//     Option JFORM=2, suitable for minor planets:
//
//     EPOCH  = epoch of elements (TT MJD)
//     ORBINC = inclination i (radians)
//     ANODE  = longitude of the ascending node, big omega (radians)
//     PERIH  = argument of perihelion, little omega (radians)
//     AORQ   = mean distance, a (AU)
//     E      = eccentricity, e
//     AORL   = mean anomaly M (radians)
//
//     Option JFORM=3, suitable for comets:
//
//     EPOCH  = epoch of perihelion (TT MJD)
//     ORBINC = inclination i (radians)
//     ANODE  = longitude of the ascending node, big omega (radians)
//     PERIH  = argument of perihelion, little omega (radians)
//     AORQ   = perihelion distance, q (AU)
//     E      = eccentricity, e
//
//  4  It may not be possible to generate elements in the form
//     requested through JFORMR.  The caller is notified of the form
//     of elements actually returned by means of the JFORM argument:
//
//      JFORMR   JFORM     meaning
//
//        1        1       OK - elements are in the requested format
//        1        2       never happens
//        1        3       orbit not elliptical
//
//        2        1       never happens
//        2        2       OK - elements are in the requested format
//        2        3       orbit not elliptical
//
//        3        1       never happens
//        3        2       never happens
//        3        3       OK - elements are in the requested format
//
//  5  The arguments returned for each value of JFORM (cf Note 6: JFORM
//     may not be the same as JFORMR) are as follows:
//
//         JFORM         1              2              3
//         EPOCH         t0             t0             T
//         ORBINC        i              i              i
//         ANODE         Omega          Omega          Omega
//         PERIH         curly pi       omega          omega
//         AORQ          a              a              q
//         E             e              e              e
//         AORL          L              M              -
//         DM            n              -              -
//
//     where:
//
//         t0           is the epoch of the elements (MJD, TT)
//         T              "    epoch of perihelion (MJD, TT)
//         i              "    inclination (radians)
//         Omega          "    longitude of the ascending node (radians)
//         curly pi       "    longitude of perihelion (radians)
//         omega          "    argument of perihelion (radians)
//         a              "    mean distance (AU)
//         q              "    perihelion distance (AU)
//         e              "    eccentricity
//         L              "    longitude (radians, 0-2pi)
//         M              "    mean anomaly (radians, 0-2pi)
//         n              "    daily motion (radians)
//         -             means no value is set
//
//  6  At very small inclinations, the longitude of the ascending node
//     ANODE becomes indeterminate and under some circumstances may be
//     set arbitrarily to zero.  Similarly, if the orbit is close to
//     circular, the true anomaly becomes indeterminate and under some
//     circumstances may be set arbitrarily to zero.  In such cases,
//     the other elements are automatically adjusted to compensate,
//     and so the elements remain a valid description of the orbit.
//
//  References:
//
//     1  Sterne, Theodore E., "An Introduction to Celestial Mechanics",
//        Interscience Publishers Inc., 1960.  Section 6.7, p199.
//
//     2  Everhart, E. & Pitkin, E.T., Am.J.Phys. 51, 712, 1983.
//
//  Called:  sla_PV2EL
//
//  P.T.Wallace   Starlink   18 March 1999
//
//  Copyright (C) 1999 Rutherford Appleton Laboratory
//


struct ue2el 
{
double JFORM;double EPOCH;double ORBINC;double ANODE;double PERIH;double AORQ;double E;double AORL;double DM;int JSTAT;

  ue2el( const double U[13],int JFORMR )
  {
   sla_ue2el_( U,&JFORMR,&JFORM,&EPOCH,&ORBINC,&ANODE,&PERIH,&AORQ,&E,&AORL,&DM,&JSTAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "JFORM,EPOCH,ORBINC,ANODE,PERIH,AORQ,E,AORL,DM,JSTAT : " << JFORM<<" "<<EPOCH<<" "<<ORBINC<<" "<<ANODE<<" "<<PERIH<<" "<<AORQ<<" "<<E<<" "<<AORL<<" "<<DM<<" "<<JSTAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const ue2el& o ) { return s << o.__str__(); }

//     - - - - -
//      E G 5 0
//     - - - - -
//
//  Transformation from B1950.0 'FK4' equatorial coordinates to
//  IAU 1958 galactic coordinates (double precision)
//
//  Given:
//     DR,DD       dp       B1950.0 'FK4' RA,Dec
//
//  Returned:
//     DL,DB       dp       galactic longitude and latitude L2,B2
//
//  (all arguments are radians)
//
//  Called:
//     sla_DCS2C, sla_DMXV, sla_DCC2S, sla_SUBET, sla_DRANRM, sla_DRANGE
//
//  Note:
//     The equatorial coordinates are B1950.0 'FK4'.  Use the
//     routine sla_EQGAL if conversion from J2000.0 coordinates
//     is required.
//
//  Reference:
//     Blaauw et al, Mon.Not.R.Astron.Soc.,121,123 (1960)
//
//  P.T.Wallace   Starlink   5 September 1993
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct eg50 
{
double DL;double DB;

  eg50( const double DR,const double DD )
  {
   sla_eg50_( &DR,&DD,&DL,&DB );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DL,DB : " << DL<<" "<<DB << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const eg50& o ) { return s << o.__str__(); }

//     - - - - -
//      I N V F
//     - - - - -
//
//  Invert a linear model of the type produced by the sla_FITXY routine.
//
//  Given:
//     FWDS    d(6)      model coefficients
//
//  Returned:
//     BKWDS   d(6)      inverse model
//     J        i        status:  0 = OK, -1 = no inverse
//
//  The models relate two sets of [X,Y] coordinates as follows.
//  Naming the elements of FWDS:
//
//     FWDS(1) = A
//     FWDS(2) = B
//     FWDS(3) = C
//     FWDS(4) = D
//     FWDS(5) = E
//     FWDS(6) = F
//
//  where two sets of coordinates [X1,Y1] and [X2,Y1] are related
//  thus:
//
//     X2 = A + B*X1 + C*Y1
//     Y2 = D + E*X1 + F*Y1
//
//  the present routine generates a new set of coefficients:
//
//     BKWDS(1) = P
//     BKWDS(2) = Q
//     BKWDS(3) = R
//     BKWDS(4) = S
//     BKWDS(5) = T
//     BKWDS(6) = U
//
//  such that:
//
//     X1 = P + Q*X2 + R*Y2
//     Y1 = S + T*X2 + U*Y2
//
//  Two successive calls to sla_INVF will thus deliver a set
//  of coefficients equal to the starting values.
//
//  To comply with the ANSI Fortran standard, FWDS and BKWDS must
//  not be the same array, even though the routine is coded to
//  work on many platforms even if this rule is violated.
//
//  See also sla_FITXY, sla_PXY, sla_XY2XY, sla_DCMPF
//
//  Last revision:   26 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct invf 
{
double BKWDS[6];int J;

  invf( const double FWDS[6] )
  {
   sla_invf_( FWDS,BKWDS,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "BKWDS,J : " << BKWDS<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const invf& o ) { return s << o.__str__(); }

//     - - - - - -
//      F K 4 5 Z
//     - - - - - -
//
//  Convert B1950.0 FK4 star data to J2000.0 FK5 assuming zero
//  proper motion in the FK5 frame (double precision)
//
//  This routine converts stars from the old, Bessel-Newcomb, FK4
//  system to the new, IAU 1976, FK5, Fricke system, in such a
//  way that the FK5 proper motion is zero.  Because such a star
//  has, in general, a non-zero proper motion in the FK4 system,
//  the routine requires the epoch at which the position in the
//  FK4 system was determined.
//
//  The method is from Appendix 2 of Ref 1, but using the constants
//  of Ref 4.
//
//  Given:
//     R1950,D1950     dp    B1950.0 FK4 RA,Dec at epoch (rad)
//     BEPOCH          dp    Besselian epoch (e.g. 1979.3D0)
//
//  Returned:
//     R2000,D2000     dp    J2000.0 FK5 RA,Dec (rad)
//
//  Notes:
//
//  1)  The epoch BEPOCH is strictly speaking Besselian, but
//      if a Julian epoch is supplied the result will be
//      affected only to a negligible extent.
//
//  2)  Conversion from Besselian epoch 1950.0 to Julian epoch
//      2000.0 only is provided for.  Conversions involving other
//      epochs will require use of the appropriate precession,
//      proper motion, and E-terms routines before and/or
//      after FK45Z is called.
//
//  3)  In the FK4 catalogue the proper motions of stars within
//      10 degrees of the poles do not embody the differential
//      E-term effect and should, strictly speaking, be handled
//      in a different manner from stars outside these regions.
//      However, given the general lack of homogeneity of the star
//      data available for routine astrometry, the difficulties of
//      handling positions that may have been determined from
//      astrometric fields spanning the polar and non-polar regions,
//      the likelihood that the differential E-terms effect was not
//      taken into account when allowing for proper motion in past
//      astrometry, and the undesirability of a discontinuity in
//      the algorithm, the decision has been made in this routine to
//      include the effect of differential E-terms on the proper
//      motions for all stars, whether polar or not.  At epoch 2000,
//      and measuring on the sky rather than in terms of dRA, the
//      errors resulting from this simplification are less than
//      1 milliarcsecond in position and 1 milliarcsecond per
//      century in proper motion.
//
//  References:
//
//     1  Aoki,S., et al, 1983.  Astron.Astrophys., 128, 263.
//
//     2  Smith, C.A. et al, 1989.  "The transformation of astrometric
//        catalog systems to the equinox J2000.0".  Astron.J. 97, 265.
//
//     3  Yallop, B.D. et al, 1989.  "Transformation of mean star places
//        from FK4 B1950.0 to FK5 J2000.0 using matrices in 6-space".
//        Astron.J. 97, 274.
//
//     4  Seidelmann, P.K. (ed), 1992.  "Explanatory Supplement to
//        the Astronomical Almanac", ISBN 0-935702-68-7.
//
//  Called:  sla_DCS2C, sla_EPJ, sla_EPB2D, sla_DCC2S, sla_DRANRM
//
//  P.T.Wallace   Starlink   21 September 1998
//
//  Copyright (C) 1998 Rutherford Appleton Laboratory
//


struct fk45z 
{
double R2000;double D2000;

  fk45z( const double R1950,const double D1950,const double BEPOCH )
  {
   sla_fk45z_( &R1950,&D1950,&BEPOCH,&R2000,&D2000 );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "R2000,D2000 : " << R2000<<" "<<D2000 << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const fk45z& o ) { return s << o.__str__(); }

//     - - - - - -
//      D I M X V
//     - - - - - -
//
//  Performs the 3-D backward unitary transformation:
//
//     vector VB = (inverse of matrix DM) * vector VA
//
//  (double precision)
//
//  (n.b.  the matrix must be unitary, as this routine assumes that
//   the inverse and transpose are identical)
//
//  Given:
//     DM       dp(3,3)    matrix
//     VA       dp(3)      vector
//
//  Returned:
//     VB       dp(3)      result vector
//
//  P.T.Wallace   Starlink   March 1986
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct dimxv 
{
double VB[3];

  dimxv( const double DM[3][3],const double VA[3] )
  {
   sla_dimxv_( DM,VA,VB );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "VB : " << VB << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dimxv& o ) { return s << o.__str__(); }

//     - - - - - -
//      D A F 2 R
//     - - - - - -
//
//  Convert degrees, arcminutes, arcseconds to radians
//  (double precision)
//
//  Given:
//     IDEG        int       degrees
//     IAMIN       int       arcminutes
//     ASEC        dp        arcseconds
//
//  Returned:
//     RAD         dp        angle in radians
//     J           int       status:  0 = OK
//                                    1 = IDEG outside range 0-359
//                                    2 = IAMIN outside range 0-59
//                                    3 = ASEC outside range 0-59.999...
//
//  Notes:
//     1)  The result is computed even if any of the range checks
//         fail.
//     2)  The sign must be dealt with outside this routine.
//
//  P.T.Wallace   Starlink   23 August 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct daf2r 
{
double RAD;int J;

  daf2r( const int IDEG,const int IAMIN,const double ASEC )
  {
   sla_daf2r_( &IDEG,&IAMIN,&ASEC,&RAD,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RAD,J : " << RAD<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const daf2r& o ) { return s << o.__str__(); }

//     - - - - - -
//      P D Q 2 H
//     - - - - - -
//
//  Hour Angle corresponding to a given parallactic angle
//
//  (double precision)
//
//  Given:
//     P       d        latitude
//     D       d        declination
//     Q       d        parallactic angle
//
//  Returned:
//     H1      d        hour angle:  first solution if any
//     J1      i        flag: 0 = solution 1 is valid
//     H2      d        hour angle:  second solution if any
//     J2      i        flag: 0 = solution 2 is valid
//
//  Called:  sla_DRANGE
//
//  P.T.Wallace   Starlink   6 October 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct pdq2h 
{
double H1;int J1;double H2;int J2;

  pdq2h( const double P,const double D,const double Q )
  {
   sla_pdq2h_( &P,&D,&Q,&H1,&J1,&H2,&J2 );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "H1,J1,H2,J2 : " << H1<<" "<<J1<<" "<<H2<<" "<<J2 << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const pdq2h& o ) { return s << o.__str__(); }

//     - - - - -
//      D E 2 H
//     - - - - -
//
//  Horizon to equatorial coordinates:  Az,El to HA,Dec
//
//  (double precision)
//
//  Given:
//     AZ      d     azimuth
//     EL      d     elevation
//     PHI     d     observatory latitude
//
//  Returned:
//     HA      d     hour angle
//     DEC     d     declination
//
//  Notes:
//
//  1)  All the arguments are angles in radians.
//
//  2)  The sign convention for azimuth is north zero, east +pi/2.
//
//  3)  HA is returned in the range +/-pi.  Declination is returned
//      in the range +/-pi/2.
//
//  4)  The latitude is (in principle) geodetic.  In critical
//      applications, corrections for polar motion should be applied.
//
//  5)  In some applications it will be important to specify the
//      correct type of elevation in order to produce the required
//      type of HA,Dec.  In particular, it may be important to
//      distinguish between the elevation as affected by refraction,
//      which will yield the "observed" HA,Dec, and the elevation
//      in vacuo, which will yield the "topocentric" HA,Dec.  If the
//      effects of diurnal aberration can be neglected, the
//      topocentric HA,Dec may be used as an approximation to the
//      "apparent" HA,Dec.
//
//  6)  No range checking of arguments is done.
//
//  7)  In applications which involve many such calculations, rather
//      than calling the present routine it will be more efficient to
//      use inline code, having previously computed fixed terms such
//      as sine and cosine of latitude.
//
//  P.T.Wallace   Starlink   21 February 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct dh2e 
{
double HA;double DEC;

  dh2e( const double AZ,const double EL,const double PHI )
  {
   sla_dh2e_( &AZ,&EL,&PHI,&HA,&DEC );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "HA,DEC : " << HA<<" "<<DEC << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dh2e& o ) { return s << o.__str__(); }

//     - - - - - - -
//      D T P S 2 C
//     - - - - - - -
//
//  From the tangent plane coordinates of a star of known RA,Dec,
//  determine the RA,Dec of the tangent point.
//
//  (double precision)
//
//  Given:
//     XI,ETA      d    tangent plane rectangular coordinates
//     RA,DEC      d    spherical coordinates
//
//  Returned:
//     RAZ1,DECZ1  d    spherical coordinates of tangent point, solution 1
//     RAZ2,DECZ2  d    spherical coordinates of tangent point, solution 2
//     N           i    number of solutions:
//                        0 = no solutions returned (note 2)
//                        1 = only the first solution is useful (note 3)
//                        2 = both solutions are useful (note 3)
//
//  Notes:
//
//  1  The RAZ1 and RAZ2 values are returned in the range 0-2pi.
//
//  2  Cases where there is no solution can only arise near the poles.
//     For example, it is clearly impossible for a star at the pole
//     itself to have a non-zero XI value, and hence it is
//     meaningless to ask where the tangent point would have to be
//     to bring about this combination of XI and DEC.
//
//  3  Also near the poles, cases can arise where there are two useful
//     solutions.  The argument N indicates whether the second of the
//     two solutions returned is useful.  N=1 indicates only one useful
//     solution, the usual case;  under these circumstances, the second
//     solution corresponds to the "over-the-pole" case, and this is
//     reflected in the values of RAZ2 and DECZ2 which are returned.
//
//  4  The DECZ1 and DECZ2 values are returned in the range +/-pi, but
//     in the usual, non-pole-crossing, case, the range is +/-pi/2.
//
//  5  This routine is the spherical equivalent of the routine sla_DTPV2C.
//
//  Called:  sla_DRANRM
//
//  P.T.Wallace   Starlink   5 June 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct dtps2c 
{
double RAZ1;double DECZ1;double RAZ2;double DECZ2;int N;

  dtps2c( const double XI,const double ETA,const double RA,const double DEC )
  {
   sla_dtps2c_( &XI,&ETA,&RA,&DEC,&RAZ1,&DECZ1,&RAZ2,&DECZ2,&N );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RAZ1,DECZ1,RAZ2,DECZ2,N : " << RAZ1<<" "<<DECZ1<<" "<<RAZ2<<" "<<DECZ2<<" "<<N << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dtps2c& o ) { return s << o.__str__(); }

//     - - - - - -
//      D M 2 A V
//     - - - - - -
//
//  From a rotation matrix, determine the corresponding axial vector.
//  (double precision)
//
//  A rotation matrix describes a rotation about some arbitrary axis,
//  called the Euler axis.  The "axial vector" returned by this routine
//  has the same direction as the Euler axis, and its magnitude is the
//  amount of rotation in radians.  (The magnitude and direction can be
//  separated by means of the routine sla_DVN.)
//
//  Given:
//    RMAT   d(3,3)   rotation matrix
//
//  Returned:
//    AXVEC  d(3)     axial vector (radians)
//
//  The reference frame rotates clockwise as seen looking along
//  the axial vector from the origin.
//
//  If RMAT is null, so is the result.
//
//  Last revision:   26 November 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct dm2av 
{
double AXVEC[3];

  dm2av( const double RMAT[3][3] )
  {
   sla_dm2av_( RMAT,AXVEC );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "AXVEC : " << AXVEC << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dm2av& o ) { return s << o.__str__(); }

//     - - - - -
//      P R E C
//     - - - - -
//
//  Form the matrix of precession between two epochs (IAU 1976, FK5)
//  (double precision)
//
//  Given:
//     EP0    dp         beginning epoch
//     EP1    dp         ending epoch
//
//  Returned:
//     RMATP  dp(3,3)    precession matrix
//
//  Notes:
//
//     1)  The epochs are TDB (loosely ET) Julian epochs.
//
//     2)  The matrix is in the sense   V(EP1)  =  RMATP * V(EP0)
//
//     3)  Though the matrix method itself is rigorous, the precession
//         angles are expressed through canonical polynomials which are
//         valid only for a limited time span.  There are also known
//         errors in the IAU precession rate.  The absolute accuracy
//         of the present formulation is better than 0.1 arcsec from
//         1960AD to 2040AD, better than 1 arcsec from 1640AD to 2360AD,
//         and remains below 3 arcsec for the whole of the period
//         500BC to 3000AD.  The errors exceed 10 arcsec outside the
//         range 1200BC to 3900AD, exceed 100 arcsec outside 4200BC to
//         5600AD and exceed 1000 arcsec outside 6800BC to 8200AD.
//         The SLALIB routine sla_PRECL implements a more elaborate
//         model which is suitable for problems spanning several
//         thousand years.
//
//  References:
//     Lieske,J.H., 1979. Astron.Astrophys.,73,282.
//      equations (6) & (7), p283.
//     Kaplan,G.H., 1981. USNO circular no. 163, pA2.
//
//  Called:  sla_DEULER
//
//  P.T.Wallace   Starlink   23 August 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct prec 
{
double RMATP[3][3];

  prec( const double EP0,const double EP1 )
  {
   sla_prec_( &EP0,&EP1,RMATP );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RMATP : " << RMATP << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const prec& o ) { return s << o.__str__(); }

//     - - - - - - -
//      R V L S R K
//     - - - - - - -
//
//  Velocity component in a given direction due to the Sun's motion
//  with respect to an adopted kinematic Local Standard of Rest.
//
//  (single precision)
//
//  Given:
//     R2000,D2000   r    J2000.0 mean RA,Dec (radians)
//
//  Result:
//     Component of "standard" solar motion in direction R2000,D2000 (km/s)
//
//  Sign convention:
//     The result is +ve when the Sun is receding from the given point on
//     the sky.
//
//  Note:  The Local Standard of Rest used here is one of several
//         "kinematical" LSRs in common use.  A kinematical LSR is the
//         mean standard of rest of specified star catalogues or stellar
//         populations.  The Sun's motion with respect to a kinematical
//         LSR is known as the "standard" solar motion.
//
//         There is another sort of LSR, the "dynamical" LSR, which is a
//         point in the vicinity of the Sun which is in a circular orbit
//         around the Galactic centre.  The Sun's motion with respect to
//         the dynamical LSR is called the "peculiar" solar motion.  To
//         obtain a radial velocity correction with respect to the
//         dynamical LSR use the routine sla_RVLSRD.
//
//  Reference:  Delhaye (1965), in "Stars and Stellar Systems", vol 5,
//              p73.
//
//  Called:
//     sla_CS2C, sla_VDV
//
//  P.T.Wallace   Starlink   11 March 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline float rvlsrk( const float R2000,const float D2000 )
{
 return sla_rvlsrk_( &R2000,&D2000 );
};
//     - - - - - - -
//      P L A N T E
//     - - - - - - -
//
//  Topocentric apparent RA,Dec of a Solar-System object whose
//  heliocentric orbital elements are known.
//
//  Given:
//     DATE     d     MJD of observation (JD - 2400000.5, Notes 1,5)
//     ELONG    d     observer's east longitude (radians, Note 2)
//     PHI      d     observer's geodetic latitude (radians, Note 2)
//     JFORM    i     choice of element set (1-3; Notes 3-6)
//     EPOCH    d     epoch of elements (TT MJD, Note 5)
//     ORBINC   d     inclination (radians)
//     ANODE    d     longitude of the ascending node (radians)
//     PERIH    d     longitude or argument of perihelion (radians)
//     AORQ     d     mean distance or perihelion distance (AU)
//     E        d     eccentricity
//     AORL     d     mean anomaly or longitude (radians, JFORM=1,2 only)
//     DM       d     daily motion (radians, JFORM=1 only )
//
//  Returned:
//     RA,DEC   d     RA, Dec (topocentric apparent, radians)
//     R        d     distance from observer (AU)
//     JSTAT    i     status:  0 = OK
//                            -1 = illegal JFORM
//                            -2 = illegal E
//                            -3 = illegal AORQ
//                            -4 = illegal DM
//                            -5 = numerical error
//
//  Called: sla_EL2UE, sla_PLANTU
//
//  Notes:
//
//  1  DATE is the instant for which the prediction is required.  It is
//     in the TT timescale (formerly Ephemeris Time, ET) and is a
//     Modified Julian Date (JD-2400000.5).
//
//  2  The longitude and latitude allow correction for geocentric
//     parallax.  This is usually a small effect, but can become
//     important for near-Earth asteroids.  Geocentric positions can be
//     generated by appropriate use of routines sla_EVP (or sla_EPV) and
//     sla_PLANEL.
//
//  3  The elements are with respect to the J2000 ecliptic and equinox.
//
//  4  A choice of three different element-set options is available:
//
//     Option JFORM = 1, suitable for the major planets:
//
//       EPOCH  = epoch of elements (TT MJD)
//       ORBINC = inclination i (radians)
//       ANODE  = longitude of the ascending node, big omega (radians)
//       PERIH  = longitude of perihelion, curly pi (radians)
//       AORQ   = mean distance, a (AU)
//       E      = eccentricity, e (range 0 to <1)
//       AORL   = mean longitude L (radians)
//       DM     = daily motion (radians)
//
//     Option JFORM = 2, suitable for minor planets:
//
//       EPOCH  = epoch of elements (TT MJD)
//       ORBINC = inclination i (radians)
//       ANODE  = longitude of the ascending node, big omega (radians)
//       PERIH  = argument of perihelion, little omega (radians)
//       AORQ   = mean distance, a (AU)
//       E      = eccentricity, e (range 0 to <1)
//       AORL   = mean anomaly M (radians)
//
//     Option JFORM = 3, suitable for comets:
//
//       EPOCH  = epoch of elements and perihelion (TT MJD)
//       ORBINC = inclination i (radians)
//       ANODE  = longitude of the ascending node, big omega (radians)
//       PERIH  = argument of perihelion, little omega (radians)
//       AORQ   = perihelion distance, q (AU)
//       E      = eccentricity, e (range 0 to 10)
//
//     Unused arguments (DM for JFORM=2, AORL and DM for JFORM=3) are not
//     accessed.
//
//  5  Each of the three element sets defines an unperturbed heliocentric
//     orbit.  For a given epoch of observation, the position of the body
//     in its orbit can be predicted from these elements, which are
//     called "osculating elements", using standard two-body analytical
//     solutions.  However, due to planetary perturbations, a given set
//     of osculating elements remains usable for only as long as the
//     unperturbed orbit that it describes is an adequate approximation
//     to reality.  Attached to such a set of elements is a date called
//     the "osculating epoch", at which the elements are, momentarily,
//     a perfect representation of the instantaneous position and
//     velocity of the body.
//
//     Therefore, for any given problem there are up to three different
//     epochs in play, and it is vital to distinguish clearly between
//     them:
//
//     . The epoch of observation:  the moment in time for which the
//       position of the body is to be predicted.
//
//     . The epoch defining the position of the body:  the moment in time
//       at which, in the absence of purturbations, the specified
//       position (mean longitude, mean anomaly, or perihelion) is
//       reached.
//
//     . The osculating epoch:  the moment in time at which the given
//       elements are correct.
//
//     For the major-planet and minor-planet cases it is usual to make
//     the epoch that defines the position of the body the same as the
//     epoch of osculation.  Thus, only two different epochs are
//     involved:  the epoch of the elements and the epoch of observation.
//
//     For comets, the epoch of perihelion fixes the position in the
//     orbit and in general a different epoch of osculation will be
//     chosen.  Thus, all three types of epoch are involved.
//
//     For the present routine:
//
//     . The epoch of observation is the argument DATE.
//
//     . The epoch defining the position of the body is the argument
//       EPOCH.
//
//     . The osculating epoch is not used and is assumed to be close
//       enough to the epoch of observation to deliver adequate accuracy.
//       If not, a preliminary call to sla_PERTEL may be used to update
//       the element-set (and its associated osculating epoch) by
//       applying planetary perturbations.
//
//  6  Two important sources for orbital elements are Horizons, operated
//     by the Jet Propulsion Laboratory, Pasadena, and the Minor Planet
//     Center, operated by the Center for Astrophysics, Harvard.
//
//     The JPL Horizons elements (heliocentric, J2000 ecliptic and
//     equinox) correspond to SLALIB arguments as follows.
//
//       Major planets:
//
//         JFORM  = 1
//         EPOCH  = JDCT-2400000.5D0
//         ORBINC = IN (in radians)
//         ANODE  = OM (in radians)
//         PERIH  = OM+W (in radians)
//         AORQ   = A
//         E      = EC
//         AORL   = MA+OM+W (in radians)
//         DM     = N (in radians)
//
//         Epoch of osculation = JDCT-2400000.5D0
//
//       Minor planets:
//
//         JFORM  = 2
//         EPOCH  = JDCT-2400000.5D0
//         ORBINC = IN (in radians)
//         ANODE  = OM (in radians)
//         PERIH  = W (in radians)
//         AORQ   = A
//         E      = EC
//         AORL   = MA (in radians)
//
//         Epoch of osculation = JDCT-2400000.5D0
//
//       Comets:
//
//         JFORM  = 3
//         EPOCH  = Tp-2400000.5D0
//         ORBINC = IN (in radians)
//         ANODE  = OM (in radians)
//         PERIH  = W (in radians)
//         AORQ   = QR
//         E      = EC
//
//         Epoch of osculation = JDCT-2400000.5D0
//
//     The MPC elements correspond to SLALIB arguments as follows.
//
//       Minor planets:
//
//         JFORM  = 2
//         EPOCH  = Epoch-2400000.5D0
//         ORBINC = Incl. (in radians)
//         ANODE  = Node (in radians)
//         PERIH  = Perih. (in radians)
//         AORQ   = a
//         E      = e
//         AORL   = M (in radians)
//
//         Epoch of osculation = Epoch-2400000.5D0
//
//       Comets:
//
//         JFORM  = 3
//         EPOCH  = T-2400000.5D0
//         ORBINC = Incl. (in radians)
//         ANODE  = Node. (in radians)
//         PERIH  = Perih. (in radians)
//         AORQ   = q
//         E      = e
//
//         Epoch of osculation = Epoch-2400000.5D0
//
//  This revision:  19 June 2004
//
//  Copyright (C) 2004 P.T.Wallace.  All rights reserved.
//


struct plante 
{
double RA;double DEC;double R;int JSTAT;

  plante( const double DATE,const double ELONG,const double PHI,const int JFORM,const double EPOCH,const double ORBINC,const double ANODE,const double PERIH,const double AORQ,const double E,const double AORL,const double DM )
  {
   sla_plante_( &DATE,&ELONG,&PHI,&JFORM,&EPOCH,&ORBINC,&ANODE,&PERIH,&AORQ,&E,&AORL,&DM,&RA,&DEC,&R,&JSTAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RA,DEC,R,JSTAT : " << RA<<" "<<DEC<<" "<<R<<" "<<JSTAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const plante& o ) { return s << o.__str__(); }

//     - - - -
//      E P B
//     - - - -
//
//  Conversion of Modified Julian Date to Besselian Epoch
//  (double precision)
//
//  Given:
//     DATE     dp       Modified Julian Date (JD - 2400000.5)
//
//  The result is the Besselian Epoch.
//
//  Reference:
//     Lieske,J.H., 1979. Astron.Astrophys.,73,282.
//
//  P.T.Wallace   Starlink   February 1984
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline double epb( const double DATE )
{
 return sla_epb_( &DATE );
};
//     - - - - - -
//      P R E C L
//     - - - - - -
//
//  Form the matrix of precession between two epochs, using the
//  model of Simon et al (1994), which is suitable for long
//  periods of time.
//
//  (double precision)
//
//  Given:
//     EP0    dp         beginning epoch
//     EP1    dp         ending epoch
//
//  Returned:
//     RMATP  dp(3,3)    precession matrix
//
//  Notes:
//
//     1)  The epochs are TDB Julian epochs.
//
//     2)  The matrix is in the sense   V(EP1)  =  RMATP * V(EP0)
//
//     3)  The absolute accuracy of the model is limited by the
//         uncertainty in the general precession, about 0.3 arcsec per
//         1000 years.  The remainder of the formulation provides a
//         precision of 1 mas over the interval from 1000AD to 3000AD,
//         0.1 arcsec from 1000BC to 5000AD and 1 arcsec from
//         4000BC to 8000AD.
//
//  Reference:
//     Simon, J.L. et al., 1994. Astron.Astrophys., 282, 663-683.
//
//  Called:  sla_DEULER
//
//  P.T.Wallace   Starlink   23 August 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct precl 
{
double RMATP[3][3];

  precl( const double EP0,const double EP1 )
  {
   sla_precl_( &EP0,&EP1,RMATP );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RMATP : " << RMATP << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const precl& o ) { return s << o.__str__(); }

//     - - - -
//      K B J
//     - - - -
//
//  Select epoch prefix 'B' or 'J'
//
//  Given:
//     JB     int     sla_DBJIN prefix status:  0=none, 1='B', 2='J'
//     E      dp      epoch - Besselian or Julian
//
//  Returned:
//     K      char    'B' or 'J'
//     J      int     status:  0=OK
//
//  If JB=0, B is assumed for E < 1984D0, otherwise J.
//
//  P.T.Wallace   Starlink   31 July 1989
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct kbj 
{
char K;int J;

  kbj( const int JB,const double E )
  {
   sla_kbj_( &JB,&E,&K,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "K,J : " << K<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const kbj& o ) { return s << o.__str__(); }

//     - - - - - -
//      P V 2 U E
//     - - - - - -
//
//  Construct a universal element set based on an instantaneous position
//  and velocity.
//
//  Given:
//     PV        d(6)   heliocentric x,y,z,xdot,ydot,zdot of date,
//                      (AU,AU/s; Note 1)
//     DATE      d      date (TT Modified Julian Date = JD-2400000.5)
//     PMASS     d      mass of the planet (Sun=1; Note 2)
//
//  Returned:
//     U         d(13)  universal orbital elements (Note 3)
//
//                 (1)  combined mass (M+m)
//                 (2)  total energy of the orbit (alpha)
//                 (3)  reference (osculating) epoch (t0)
//               (4-6)  position at reference epoch (r0)
//               (7-9)  velocity at reference epoch (v0)
//                (10)  heliocentric distance at reference epoch
//                (11)  r0.v0
//                (12)  date (t)
//                (13)  universal eccentric anomaly (psi) of date, approx
//
//     JSTAT     i      status:  0 = OK
//                              -1 = illegal PMASS
//                              -2 = too close to Sun
//                              -3 = too slow
//
//  Notes
//
//  1  The PV 6-vector can be with respect to any chosen inertial frame,
//     and the resulting universal-element set will be with respect to
//     the same frame.  A common choice will be mean equator and ecliptic
//     of epoch J2000.
//
//  2  The mass, PMASS, is important only for the larger planets.  For
//     most purposes (e.g. asteroids) use 0D0.  Values less than zero
//     are illegal.
//
//  3  The "universal" elements are those which define the orbit for the
//     purposes of the method of universal variables (see reference).
//     They consist of the combined mass of the two bodies, an epoch,
//     and the position and velocity vectors (arbitrary reference frame)
//     at that epoch.  The parameter set used here includes also various
//     quantities that can, in fact, be derived from the other
//     information.  This approach is taken to avoiding unnecessary
//     computation and loss of accuracy.  The supplementary quantities
//     are (i) alpha, which is proportional to the total energy of the
//     orbit, (ii) the heliocentric distance at epoch, (iii) the
//     outwards component of the velocity at the given epoch, (iv) an
//     estimate of psi, the "universal eccentric anomaly" at a given
//     date and (v) that date.
//
//  Reference:  Everhart, E. & Pitkin, E.T., Am.J.Phys. 51, 712, 1983.
//
//  P.T.Wallace   Starlink   18 March 1999
//
//  Copyright (C) 1999 Rutherford Appleton Laboratory
//


struct pv2ue 
{
double U[13];int JSTAT;

  pv2ue( const double PV[6],const double DATE,const double PMASS )
  {
   sla_pv2ue_( PV,&DATE,&PMASS,U,&JSTAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "U,JSTAT : " << U<<" "<<JSTAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const pv2ue& o ) { return s << o.__str__(); }

//     - - - - - -
//      D C S 2 C
//     - - - - - -
//
//  Spherical coordinates to direction cosines (double precision)
//
//  Given:
//     A,B       d      spherical coordinates in radians
//                         (RA,Dec), (long,lat) etc.
//
//  Returned:
//     V         d(3)   x,y,z unit vector
//
//  The spherical coordinates are longitude (+ve anticlockwise looking
//  from the +ve latitude pole) and latitude.  The Cartesian coordinates
//  are right handed, with the x axis at zero longitude and latitude, and
//  the z axis at the +ve latitude pole.
//
//  Last revision:   26 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct dcs2c 
{
double V[3];

  dcs2c( const double A,const double B )
  {
   sla_dcs2c_( &A,&B,V );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "V : " << V << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dcs2c& o ) { return s << o.__str__(); }

//     - - - - - -
//      F K 5 4 Z
//     - - - - - -
//
//  Convert a J2000.0 FK5 star position to B1950.0 FK4 assuming
//  zero proper motion and parallax (double precision)
//
//  This routine converts star positions from the new, IAU 1976,
//  FK5, Fricke system to the old, Bessel-Newcomb, FK4 system.
//
//  Given:
//     R2000,D2000     dp    J2000.0 FK5 RA,Dec (rad)
//     BEPOCH          dp    Besselian epoch (e.g. 1950D0)
//
//  Returned:
//     R1950,D1950     dp    B1950.0 FK4 RA,Dec (rad) at epoch BEPOCH
//     DR1950,DD1950   dp    B1950.0 FK4 proper motions (rad/trop.yr)
//
//  Notes:
//
//  1)  The proper motion in RA is dRA/dt rather than cos(Dec)*dRA/dt.
//
//  2)  Conversion from Julian epoch 2000.0 to Besselian epoch 1950.0
//      only is provided for.  Conversions involving other epochs will
//      require use of the appropriate precession routines before and
//      after this routine is called.
//
//  3)  Unlike in the sla_FK524 routine, the FK5 proper motions, the
//      parallax and the radial velocity are presumed zero.
//
//  4)  It is the intention that FK5 should be a close approximation
//      to an inertial frame, so that distant objects have zero proper
//      motion;  such objects have (in general) non-zero proper motion
//      in FK4, and this routine returns those fictitious proper
//      motions.
//
//  5)  The position returned by this routine is in the B1950
//      reference frame but at Besselian epoch BEPOCH.  For
//      comparison with catalogues the BEPOCH argument will
//      frequently be 1950D0.
//
//  Called:  sla_FK524, sla_PM
//
//  P.T.Wallace   Starlink   10 April 1990
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct fk54z 
{
double R1950;double D1950;double DR1950;double DD1950;

  fk54z( const double R2000,const double D2000,const double BEPOCH )
  {
   sla_fk54z_( &R2000,&D2000,&BEPOCH,&R1950,&D1950,&DR1950,&DD1950 );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "R1950,D1950,DR1950,DD1950 : " << R1950<<" "<<D1950<<" "<<DR1950<<" "<<DD1950 << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const fk54z& o ) { return s << o.__str__(); }

//     - - - - - -
//      I D C H F
//     - - - - - -
//
//  Internal routine used by DFLTIN
//
//  Identify next character in string
//
//  Given:
//     STRING      char        string
//     NPTR        int         pointer to character to be identified
//
//  Returned:
//     NPTR        int         incremented unless end of field
//     NVEC        int         vector for identified character
//     NDIGIT      int         0-9 if character was a numeral
//     DIGIT       double      equivalent of NDIGIT
//
//     NVEC takes the following values:
//
//      1     0-9
//      2     space or TAB   !!! n.b. ASCII TAB assumed !!!
//      3     D,d,E or e
//      4     .
//      5     +
//      6     -
//      7     ,
//      8     else
//      9     outside field
//
//  If the character is not 0-9, NDIGIT and DIGIT are either not
//  altered or are set to arbitrary values.
//
//  P.T.Wallace   Starlink   22 December 1992
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct _idchf 
{
int NVEC;int NDIGIT;double DIGIT;

  _idchf( const char STRING,int NPTR )
  {
   sla__idchf_( &STRING,&NPTR,&NVEC,&NDIGIT,&DIGIT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "NVEC,NDIGIT,DIGIT : " << NVEC<<" "<<NDIGIT<<" "<<DIGIT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const _idchf& o ) { return s << o.__str__(); }

//     - - - - -
//      D J C L
//     - - - - -
//
//  Modified Julian Date to Gregorian year, month, day,
//  and fraction of a day.
//
//  Given:
//     DJM      dp     modified Julian Date (JD-2400000.5)
//
//  Returned:
//     IY       int    year
//     IM       int    month
//     ID       int    day
//     FD       dp     fraction of day
//     J        int    status:
//                       0 = OK
//                      -1 = unacceptable date (before 4701BC March 1)
//
//  The algorithm is adapted from Hatcher 1984 (QJRAS 25, 53-55).
//
//  Last revision:   22 July 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct djcl 
{
int IY;int IM;int ID;double FD;int J;

  djcl( const double DJM )
  {
   sla_djcl_( &DJM,&IY,&IM,&ID,&FD,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "IY,IM,ID,FD,J : " << IY<<" "<<IM<<" "<<ID<<" "<<FD<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const djcl& o ) { return s << o.__str__(); }

//     - - - - - -
//      E Q E Q X
//     - - - - - -
//
//  Equation of the equinoxes  (IAU 1994, double precision)
//
//  Given:
//     DATE    dp      TDB (loosely ET) as Modified Julian Date
//                                          (JD-2400000.5)
//
//  The result is the equation of the equinoxes (double precision)
//  in radians:
//
//     Greenwich apparent ST = GMST + sla_EQEQX
//
//  References:  IAU Resolution C7, Recommendation 3 (1994)
//               Capitaine, N. & Gontier, A.-M., Astron. Astrophys.,
//               275, 645-650 (1993)
//
//  Called:  sla_NUTC
//
//  Patrick Wallace   Starlink   23 August 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


inline double eqeqx( const double DATE )
{
 return sla_eqeqx_( &DATE );
};
//     - - - - - -
//      D C 6 2 S
//     - - - - - -
//
//  Conversion of position & velocity in Cartesian coordinates
//  to spherical coordinates (double precision)
//
//  Given:
//     V      d(6)   Cartesian position & velocity vector
//
//  Returned:
//     A      d      longitude (radians)
//     B      d      latitude (radians)
//     R      d      radial coordinate
//     AD     d      longitude derivative (radians per unit time)
//     BD     d      latitude derivative (radians per unit time)
//     RD     d      radial derivative
//
//  P.T.Wallace   Starlink   28 April 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct dc62s 
{
double A;double B;double R;double AD;double BD;double RD;

  dc62s( const double V[6] )
  {
   sla_dc62s_( V,&A,&B,&R,&AD,&BD,&RD );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "A,B,R,AD,BD,RD : " << A<<" "<<B<<" "<<R<<" "<<AD<<" "<<BD<<" "<<RD << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dc62s& o ) { return s << o.__str__(); }

//     - - - - - -
//      E Q G A L
//     - - - - - -
//
//  Transformation from J2000.0 equatorial coordinates to
//  IAU 1958 galactic coordinates (double precision)
//
//  Given:
//     DR,DD       dp       J2000.0 RA,Dec
//
//  Returned:
//     DL,DB       dp       galactic longitude and latitude L2,B2
//
//  (all arguments are radians)
//
//  Called:
//     sla_DCS2C, sla_DMXV, sla_DCC2S, sla_DRANRM, sla_DRANGE
//
//  Note:
//     The equatorial coordinates are J2000.0.  Use the routine
//     sla_EG50 if conversion from B1950.0 'FK4' coordinates is
//     required.
//
//  Reference:
//     Blaauw et al, Mon.Not.R.Astron.Soc.,121,123 (1960)
//
//  P.T.Wallace   Starlink   21 September 1998
//
//  Copyright (C) 1998 Rutherford Appleton Laboratory
//


struct eqgal 
{
double DL;double DB;

  eqgal( const double DR,const double DD )
  {
   sla_eqgal_( &DR,&DD,&DL,&DB );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DL,DB : " << DL<<" "<<DB << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const eqgal& o ) { return s << o.__str__(); }

//     - - - - -
//      G E 5 0
//     - - - - -
//
//  Transformation from IAU 1958 galactic coordinates to
//  B1950.0 'FK4' equatorial coordinates (double precision)
//
//  Given:
//     DL,DB       dp       galactic longitude and latitude L2,B2
//
//  Returned:
//     DR,DD       dp       B1950.0 'FK4' RA,Dec
//
//  (all arguments are radians)
//
//  Called:
//     sla_DCS2C, sla_DIMXV, sla_DCC2S, sla_ADDET, sla_DRANRM, sla_DRANGE
//
//  Note:
//     The equatorial coordinates are B1950.0 'FK4'.  Use the
//     routine sla_GALEQ if conversion to J2000.0 coordinates
//     is required.
//
//  Reference:
//     Blaauw et al, Mon.Not.R.Astron.Soc.,121,123 (1960)
//
//  P.T.Wallace   Starlink   5 September 1993
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct ge50 
{
double DR;double DD;

  ge50( const double DL,const double DB )
  {
   sla_ge50_( &DL,&DB,&DR,&DD );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DR,DD : " << DR<<" "<<DD << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const ge50& o ) { return s << o.__str__(); }

//     - - - - -
//      E P C O
//     - - - - -
//
//  Convert an epoch into the appropriate form - 'B' or 'J'
//
//  Given:
//     K0    char    form of result:  'B'=Besselian, 'J'=Julian
//     K     char    form of given epoch:  'B' or 'J'
//     E     dp      epoch
//
//  Called:  sla_EPB, sla_EPJ2D, sla_EPJ, sla_EPB2D
//
//  Notes:
//
//     1) The result is always either equal to or very close to
//        the given epoch E.  The routine is required only in
//        applications where punctilious treatment of heterogeneous
//        mixtures of star positions is necessary.
//
//     2) K0 and K are not validated.  They are interpreted as follows:
//
//        o  If K0 and K are the same the result is E.
//        o  If K0 is 'B' or 'b' and K isn't, the conversion is J to B.
//        o  In all other cases, the conversion is B to J.
//
//        Note that K0 and K won't match if their cases differ.
//
//  P.T.Wallace   Starlink   5 September 1993
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline double epco( const char K0,const char K,const double E )
{
 return sla_epco_( &K0,&K,&E );
};
//     - - - - -
//      R V L G
//     - - - - -
//
//  Velocity component in a given direction due to the combination
//  of the rotation of the Galaxy and the motion of the Galaxy
//  relative to the mean motion of the local group (single precision)
//
//  Given:
//     R2000,D2000   real    J2000.0 mean RA,Dec (radians)
//
//  Result:
//     Component of SOLAR motion in direction R2000,D2000 (km/s)
//
//  Sign convention:
//     The result is +ve when the Sun is receding from the
//     given point on the sky.
//
//  Reference:
//     IAU Trans 1976, 168, p201.
//
//  Called:
//     sla_CS2C, sla_VDV
//
//  P.T.Wallace   Starlink   June 1985
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline float rvlg( const float R2000,const float D2000 )
{
 return sla_rvlg_( &R2000,&D2000 );
};
//     - - - - - -
//      C S 2 C 6
//     - - - - - -
//
//  Conversion of position & velocity in spherical coordinates
//  to Cartesian coordinates (single precision)
//
//  Given:
//     A     r      longitude (radians)
//     B     r      latitude (radians)
//     R     r      radial coordinate
//     AD    r      longitude derivative (radians per unit time)
//     BD    r      latitude derivative (radians per unit time)
//     RD    r      radial derivative
//
//  Returned:
//     V     r(6)   Cartesian position & velocity vector
//
//  Last revision:   11 September 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct cs2c6 
{
float V[6];

  cs2c6( const float A,const float B,const float R,const float AD,const float BD,const float RD )
  {
   sla_cs2c6_( &A,&B,&R,&AD,&BD,&RD,V );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "V : " << V << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const cs2c6& o ) { return s << o.__str__(); }

//     - - - - -
//      S 2 T P
//     - - - - -
//
//  Projection of spherical coordinates onto tangent plane:
//  "gnomonic" projection - "standard coordinates"
//  (single precision)
//
//  Given:
//     RA,DEC      real  spherical coordinates of point to be projected
//     RAZ,DECZ    real  spherical coordinates of tangent point
//
//  Returned:
//     XI,ETA      real  rectangular coordinates on tangent plane
//     J           int   status:   0 = OK, star on tangent plane
//                                 1 = error, star too far from axis
//                                 2 = error, antistar on tangent plane
//                                 3 = error, antistar too far from axis
//
//  P.T.Wallace   Starlink   18 July 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct s2tp 
{
float XI;float ETA;int J;

  s2tp( const float RA,const float DEC,const float RAZ,const float DECZ )
  {
   sla_s2tp_( &RA,&DEC,&RAZ,&DECZ,&XI,&ETA,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "XI,ETA,J : " << XI<<" "<<ETA<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const s2tp& o ) { return s << o.__str__(); }

//     - - - - -
//      C C 2 S
//     - - - - -
//
//  Cartesian to spherical coordinates (single precision)
//
//  Given:
//     V     r(3)   x,y,z vector
//
//  Returned:
//     A,B   r      spherical coordinates in radians
//
//  The spherical coordinates are longitude (+ve anticlockwise looking
//  from the +ve latitude pole) and latitude.  The Cartesian coordinates
//  are right handed, with the x axis at zero longitude and latitude, and
//  the z axis at the +ve latitude pole.
//
//  If V is null, zero A and B are returned.  At either pole, zero A is
//  returned.
//
//  Last revision:   22 July 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct cc2s 
{
float A;float B;

  cc2s( const float V[3] )
  {
   sla_cc2s_( V,&A,&B );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "A,B : " << A<<" "<<B << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const cc2s& o ) { return s << o.__str__(); }

//     - - - - - - -
//      R A N O R M
//     - - - - - - -
//
//  Normalize angle into range 0-2 pi  (single precision)
//
//  Given:
//     ANGLE     dp      the angle in radians
//
//  The result is ANGLE expressed in the range 0-2 pi (single
//  precision).
//
//  P.T.Wallace   Starlink   23 November 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline float ranorm( const double ANGLE )
{
 return sla_ranorm_( &ANGLE );
};
//     - - - -
//      N U T
//     - - - -
//
//  Form the matrix of nutation for a given date - Shirai & Fukushima
//  2001 theory (double precision)
//
//  Reference:
//     Shirai, T. & Fukushima, T., Astron.J. 121, 3270-3283 (2001).
//
//  Given:
//     DATE    d          TDB (loosely ET) as Modified Julian Date
//                                           (=JD-2400000.5)
//  Returned:
//     RMATN   d(3,3)     nutation matrix
//
//  Notes:
//
//  1  The matrix is in the sense  v(true) = rmatn * v(mean) .
//     where v(true) is the star vector relative to the true equator and
//     equinox of date and v(mean) is the star vector relative to the
//     mean equator and equinox of date.
//
//  2  The matrix represents forced nutation (but not free core
//     nutation) plus corrections to the IAU~1976 precession model.
//
//  3  Earth attitude predictions made by combining the present nutation
//     matrix with IAU~1976 precession are accurate to 1~mas (with
//     respect to the ICRS) for a few decades around 2000.
//
//  4  The distinction between the required TDB and TT is always
//     negligible.  Moreover, for all but the most critical applications
//     UTC is adequate.
//
//  Called:   sla_NUTC, sla_DEULER
//
//  Last revision:   1 December 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct nut 
{
double RMATN[3][3];

  nut( const double DATE )
  {
   sla_nut_( &DATE,RMATN );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RMATN : " << RMATN << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const nut& o ) { return s << o.__str__(); }

//     - - - - -
//      V 2 T P
//     - - - - -
//
//  Given the direction cosines of a star and of the tangent point,
//  determine the star's tangent-plane coordinates.
//
//  (single precision)
//
//  Given:
//     V         r(3)    direction cosines of star
//     V0        r(3)    direction cosines of tangent point
//
//  Returned:
//     XI,ETA    r       tangent plane coordinates of star
//     J         i       status:   0 = OK
//                                 1 = error, star too far from axis
//                                 2 = error, antistar on tangent plane
//                                 3 = error, antistar too far from axis
//
//  Notes:
//
//  1  If vector V0 is not of unit length, or if vector V is of zero
//     length, the results will be wrong.
//
//  2  If V0 points at a pole, the returned XI,ETA will be based on the
//     arbitrary assumption that the RA of the tangent point is zero.
//
//  3  This routine is the Cartesian equivalent of the routine sla_S2TP.
//
//  P.T.Wallace   Starlink   27 November 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct v2tp 
{
float XI;float ETA;int J;

  v2tp( const float V[3],const float V0[3] )
  {
   sla_v2tp_( V,V0,&XI,&ETA,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "XI,ETA,J : " << XI<<" "<<ETA<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const v2tp& o ) { return s << o.__str__(); }

//     - - - - - -
//      D J C A L
//     - - - - - -
//
//  Modified Julian Date to Gregorian Calendar, expressed
//  in a form convenient for formatting messages (namely
//  rounded to a specified precision, and with the fields
//  stored in a single array)
//
//  Given:
//     NDP      i      number of decimal places of days in fraction
//     DJM      d      modified Julian Date (JD-2400000.5)
//
//  Returned:
//     IYMDF    i(4)   year, month, day, fraction in Gregorian
//                     calendar
//     J        i      status:  nonzero = out of range
//
//  Any date after 4701BC March 1 is accepted.
//
//  NDP should be 4 or less if internal overflows are to be avoided
//  on machines which use 32-bit integers.
//
//  The algorithm is adapted from Hatcher 1984 (QJRAS 25, 53-55).
//
//  Last revision:   22 July 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct djcal 
{
int IYMDF[4];int J;

  djcal( int NDP,const double DJM )
  {
   sla_djcal_( &NDP,&DJM,IYMDF,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "IYMDF,J : " << IYMDF<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const djcal& o ) { return s << o.__str__(); }

//     - - - - - - -
//      D T P V 2 C
//     - - - - - - -
//
//  Given the tangent-plane coordinates of a star and its direction
//  cosines, determine the direction cosines of the tangent-point.
//
//  (double precision)
//
//  Given:
//     XI,ETA    d       tangent plane coordinates of star
//     V         d(3)    direction cosines of star
//
//  Returned:
//     V01       d(3)    direction cosines of tangent point, solution 1
//     V02       d(3)    direction cosines of tangent point, solution 2
//     N         i       number of solutions:
//                         0 = no solutions returned (note 2)
//                         1 = only the first solution is useful (note 3)
//                         2 = both solutions are useful (note 3)
//
//  Notes:
//
//  1  The vector V must be of unit length or the result will be wrong.
//
//  2  Cases where there is no solution can only arise near the poles.
//     For example, it is clearly impossible for a star at the pole
//     itself to have a non-zero XI value, and hence it is meaningless
//     to ask where the tangent point would have to be.
//
//  3  Also near the poles, cases can arise where there are two useful
//     solutions.  The argument N indicates whether the second of the
//     two solutions returned is useful.  N=1 indicates only one useful
//     solution, the usual case;  under these circumstances, the second
//     solution can be regarded as valid if the vector V02 is interpreted
//     as the "over-the-pole" case.
//
//  4  This routine is the Cartesian equivalent of the routine sla_DTPS2C.
//
//  P.T.Wallace   Starlink   5 June 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct dtpv2c 
{
double V01[3];double V02[3];int N;

  dtpv2c( const double XI,const double ETA,const double V[3] )
  {
   sla_dtpv2c_( &XI,&ETA,V,V01,V02,&N );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "V01,V02,N : " << V01<<" "<<V02<<" "<<N << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dtpv2c& o ) { return s << o.__str__(); }

//     - - - - - -
//      I D C H I
//     - - - - - -
//
//  Internal routine used by INTIN
//
//  Identify next character in string
//
//  Given:
//     STRING      char        string
//     NPTR        int         pointer to character to be identified
//
//  Returned:
//     NPTR        int         incremented unless end of field
//     NVEC        int         vector for identified character
//     DIGIT       double      double precision digit if 0-9
//
//     NVEC takes the following values:
//
//      1     0-9
//      2     space or TAB   !!! n.b. ASCII TAB assumed !!!
//      3     +
//      4     -
//      5     ,
//      6     else
//      7     outside string
//
//  If the character is not 0-9, DIGIT is either unaltered or
//  is set to an arbitrary value.
//
//  P.T.Wallace   Starlink   22 December 1992
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct _idchi 
{
int NVEC;double DIGIT;

  _idchi( const char STRING,int NPTR )
  {
   sla__idchi_( &STRING,&NPTR,&NVEC,&DIGIT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "NVEC,DIGIT : " << NVEC<<" "<<DIGIT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const _idchi& o ) { return s << o.__str__(); }

//     - - - -
//      D T T
//     - - - -
//
//  Increment to be applied to Coordinated Universal Time UTC to give
//  Terrestrial Time TT (formerly Ephemeris Time ET)
//
//  (double precision)
//
//  Given:
//     UTC      d      UTC date as a modified JD (JD-2400000.5)
//
//  Result:  TT-UTC in seconds
//
//  Notes:
//
//  1  The UTC is specified to be a date rather than a time to indicate
//     that care needs to be taken not to specify an instant which lies
//     within a leap second.  Though in most cases UTC can include the
//     fractional part, correct behaviour on the day of a leap second
//     can only be guaranteed up to the end of the second 23:59:59.
//
//  2  Pre 1972 January 1 a fixed value of 10 + ET-TAI is returned.
//
//  3  See also the routine sla_DT, which roughly estimates ET-UT for
//     historical epochs.
//
//  Called:  sla_DAT
//
//  P.T.Wallace   Starlink   6 December 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline double dtt( const double UTC )
{
 return sla_dtt_( &UTC );
};
//     - - - - - -
//      D S 2 C 6
//     - - - - - -
//
//  Conversion of position & velocity in spherical coordinates
//  to Cartesian coordinates
//
//  (double precision)
//
//  Given:
//     A     dp      longitude (radians)
//     B     dp      latitude (radians)
//     R     dp      radial coordinate
//     AD    dp      longitude derivative (radians per unit time)
//     BD    dp      latitude derivative (radians per unit time)
//     RD    dp      radial derivative
//
//  Returned:
//     V     dp(6)   Cartesian position & velocity vector
//
//  P.T.Wallace   Starlink   10 July 1993
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct ds2c6 
{
double V[6];

  ds2c6( const double A,const double B,const double R,const double AD,const double BD,const double RD )
  {
   sla_ds2c6_( &A,&B,&R,&AD,&BD,&RD,V );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "V : " << V << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const ds2c6& o ) { return s << o.__str__(); }

//     - - - - - -
//      E T R M S
//     - - - - - -
//
//  Compute the E-terms (elliptic component of annual aberration)
//  vector (double precision)
//
//  Given:
//     EP      dp      Besselian epoch
//
//  Returned:
//     EV      dp(3)   E-terms as (dx,dy,dz)
//
//  Note the use of the J2000 aberration constant (20.49552 arcsec).
//  This is a reflection of the fact that the E-terms embodied in
//  existing star catalogues were computed from a variety of
//  aberration constants.  Rather than adopting one of the old
//  constants the latest value is used here.
//
//  References:
//     1  Smith, C.A. et al., 1989.  Astr.J. 97, 265.
//     2  Yallop, B.D. et al., 1989.  Astr.J. 97, 274.
//
//  P.T.Wallace   Starlink   23 August 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct etrms 
{
double EV[3];

  etrms( const double EP )
  {
   sla_etrms_( &EP,EV );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "EV : " << EV << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const etrms& o ) { return s << o.__str__(); }

//     - - - - - - -
//      R E F C O Q
//     - - - - - - -
//
//  Determine the constants A and B in the atmospheric refraction
//  model dZ = A tan Z + B tan**3 Z.  This is a fast alternative
//  to the sla_REFCO routine - see notes.
//
//  Z is the "observed" zenith distance (i.e. affected by refraction)
//  and dZ is what to add to Z to give the "topocentric" (i.e. in vacuo)
//  zenith distance.
//
//  Given:
//    TDK      d      ambient temperature at the observer (K)
//    PMB      d      pressure at the observer (millibar)
//    RH       d      relative humidity at the observer (range 0-1)
//    WL       d      effective wavelength of the source (micrometre)
//
//  Returned:
//    REFA     d      tan Z coefficient (radian)
//    REFB     d      tan**3 Z coefficient (radian)
//
//  The radio refraction is chosen by specifying WL > 100 micrometres.
//
//  Notes:
//
//  1  The model is an approximation, for moderate zenith distances,
//     to the predictions of the sla_REFRO routine.  The approximation
//     is maintained across a range of conditions, and applies to
//     both optical/IR and radio.
//
//  2  The algorithm is a fast alternative to the sla_REFCO routine.
//     The latter calls the sla_REFRO routine itself:  this involves
//     integrations through a model atmosphere, and is costly in
//     processor time.  However, the model which is produced is precisely
//     correct for two zenith distance (45 degrees and about 76 degrees)
//     and at other zenith distances is limited in accuracy only by the
//     A tan Z + B tan**3 Z formulation itself.  The present routine
//     is not as accurate, though it satisfies most practical
//     requirements.
//
//  3  The model omits the effects of (i) height above sea level (apart
//     from the reduced pressure itself), (ii) latitude (i.e. the
//     flattening of the Earth) and (iii) variations in tropospheric
//     lapse rate.
//
//     The model was tested using the following range of conditions:
//
//       lapse rates 0.0055, 0.0065, 0.0075 K/metre
//       latitudes 0, 25, 50, 75 degrees
//       heights 0, 2500, 5000 metres ASL
//       pressures mean for height -10% to +5% in steps of 5%
//       temperatures -10 deg to +20 deg with respect to 280 deg at SL
//       relative humidity 0, 0.5, 1
//       wavelengths 0.4, 0.6, ... 2 micron, + radio
//       zenith distances 15, 45, 75 degrees
//
//     The accuracy with respect to direct use of the sla_REFRO routine
//     was as follows:
//
//                            worst         RMS
//
//       optical/IR           62 mas       8 mas
//       radio               319 mas      49 mas
//
//     For this particular set of conditions:
//
//       lapse rate 0.0065 K/metre
//       latitude 50 degrees
//       sea level
//       pressure 1005 mb
//       temperature 280.15 K
//       humidity 80%
//       wavelength 5740 Angstroms
//
//     the results were as follows:
//
//       ZD        sla_REFRO   sla_REFCOQ  Saastamoinen
//
//       10         10.27        10.27        10.27
//       20         21.19        21.20        21.19
//       30         33.61        33.61        33.60
//       40         48.82        48.83        48.81
//       45         58.16        58.18        58.16
//       50         69.28        69.30        69.27
//       55         82.97        82.99        82.95
//       60        100.51       100.54       100.50
//       65        124.23       124.26       124.20
//       70        158.63       158.68       158.61
//       72        177.32       177.37       177.31
//       74        200.35       200.38       200.32
//       76        229.45       229.43       229.42
//       78        267.44       267.29       267.41
//       80        319.13       318.55       319.10
//
//      deg        arcsec       arcsec       arcsec
//
//     The values for Saastamoinen's formula (which includes terms
//     up to tan^5) are taken from Hohenkerk and Sinclair (1985).
//
//     The results from the much slower but more accurate sla_REFCO
//     routine have not been included in the tabulation as they are
//     identical to those in the sla_REFRO column to the 0.01 arcsec
//     resolution used.
//
//  4  Outlandish input parameters are silently limited to mathematically
//     safe values.  Zero pressure is permissible, and causes zeroes to
//     be returned.
//
//  5  The algorithm draws on several sources, as follows:
//
//     a) The formula for the saturation vapour pressure of water as
//        a function of temperature and temperature is taken from
//        expressions A4.5-A4.7 of Gill (1982).
//
//     b) The formula for the water vapour pressure, given the
//        saturation pressure and the relative humidity, is from
//        Crane (1976), expression 2.5.5.
//
//     c) The refractivity of air is a function of temperature,
//        total pressure, water-vapour pressure and, in the case
//        of optical/IR but not radio, wavelength.  The formulae
//        for the two cases are developed from Hohenkerk & Sinclair
//        (1985) and Rueger (2002).
//
//     The above three items are as used in the sla_REFRO routine.
//
//     d) The formula for beta, the ratio of the scale height of the
//        atmosphere to the geocentric distance of the observer, is
//        an adaption of expression 9 from Stone (1996).  The
//        adaptations, arrived at empirically, consist of (i) a
//        small adjustment to the coefficient and (ii) a humidity
//        term for the radio case only.
//
//     e) The formulae for the refraction constants as a function of
//        n-1 and beta are from Green (1987), expression 4.31.
//
//  References:
//
//     Crane, R.K., Meeks, M.L. (ed), "Refraction Effects in the Neutral
//     Atmosphere", Methods of Experimental Physics: Astrophysics 12B,
//     Academic Press, 1976.
//
//     Gill, Adrian E., "Atmosphere-Ocean Dynamics", Academic Press, 1982.
//
//     Green, R.M., "Spherical Astronomy", Cambridge University Press, 1987.
//
//     Hohenkerk, C.Y., & Sinclair, A.T., NAO Technical Note No. 63, 1985.
//
//     Rueger, J.M., "Refractive Index Formulae for Electronic Distance
//     Measurement with Radio and Millimetre Waves", in Unisurv Report
//     S-68, School of Surveying and Spatial Information Systems,
//     University of New South Wales, Sydney, Australia, 2002.
//
//     Stone, Ronald C., P.A.S.P. 108 1051-1058, 1996.
//
//  Last revision:   2 December 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct refcoq 
{
double REFA;double REFB;

  refcoq( const double TDK,const double PMB,const double RH,const double WL )
  {
   sla_refcoq_( &TDK,&PMB,&RH,&WL,&REFA,&REFB );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "REFA,REFB : " << REFA<<" "<<REFB << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const refcoq& o ) { return s << o.__str__(); }

//     - - - - - -
//      E Q E C L
//     - - - - - -
//
//  Transformation from J2000.0 equatorial coordinates to
//  ecliptic coordinates (double precision)
//
//  Given:
//     DR,DD       dp      J2000.0 mean RA,Dec (radians)
//     DATE        dp      TDB (loosely ET) as Modified Julian Date
//                                              (JD-2400000.5)
//  Returned:
//     DL,DB       dp      ecliptic longitude and latitude
//                         (mean of date, IAU 1980 theory, radians)
//
//  Called:
//     sla_DCS2C, sla_PREC, sla_EPJ, sla_DMXV, sla_ECMAT, sla_DCC2S,
//     sla_DRANRM, sla_DRANGE
//
//  P.T.Wallace   Starlink   March 1986
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct eqecl 
{
double DL;double DB;

  eqecl( const double DR,const double DD,const double DATE )
  {
   sla_eqecl_( &DR,&DD,&DATE,&DL,&DB );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DL,DB : " << DL<<" "<<DB << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const eqecl& o ) { return s << o.__str__(); }

//     - - - - - -
//      G M S T A
//     - - - - - -
//
//  Conversion from Universal Time to Greenwich mean sidereal time,
//  with rounding errors minimized.
//
//  double precision
//
//  Given:
//    DATE    d      UT1 date (MJD: integer part of JD-2400000.5))
//    UT      d      UT1 time (fraction of a day)
//
//  The result is the Greenwich mean sidereal time (double precision,
//  radians, in the range 0 to 2pi).
//
//  There is no restriction on how the UT is apportioned between the
//  DATE and UT arguments.  Either of the two arguments could, for
//  example, be zero and the entire date+time supplied in the other.
//  However, the routine is designed to deliver maximum accuracy when
//  the DATE argument is a whole number and the UT lies in the range
//  0 to 1 (or vice versa).
//
//  The algorithm is based on the IAU 1982 expression (see page S15 of
//  the 1984 Astronomical Almanac).  This is always described as giving
//  the GMST at 0 hours UT1.  In fact, it gives the difference between
//  the GMST and the UT, the steady 4-minutes-per-day drawing-ahead of
//  ST with respect to UT.  When whole days are ignored, the expression
//  happens to equal the GMST at 0 hours UT1 each day.  Note that the
//  factor 1.0027379... does not appear explicitly but in the form of
//  the coefficient 8640184.812866, which is 86400x36525x0.0027379...
//
//  In this routine, the entire UT1 (the sum of the two arguments DATE
//  and UT) is used directly as the argument for the standard formula.
//  The UT1 is then added, but omitting whole days to conserve accuracy.
//
//  See also the routine sla_GMST, which accepts the UT as a single
//  argument.  Compared with sla_GMST, the extra numerical precision
//  delivered by the present routine is unlikely to be important in
//  an absolute sense, but may be useful when critically comparing
//  algorithms and in applications where two sidereal times close
//  together are differenced.
//
//  Called:  sla_DRANRM
//
//  P.T.Wallace   Starlink   14 October 2001
//
//  Copyright (C) 2001 Rutherford Appleton Laboratory
//


inline double gmsta( const double DATE,const double UT )
{
 return sla_gmsta_( &DATE,&UT );
};
//     - - - - - -
//      T P S 2 C
//     - - - - - -
//
//  From the tangent plane coordinates of a star of known RA,Dec,
//  determine the RA,Dec of the tangent point.
//
//  (single precision)
//
//  Given:
//     XI,ETA      r    tangent plane rectangular coordinates
//     RA,DEC      r    spherical coordinates
//
//  Returned:
//     RAZ1,DECZ1  r    spherical coordinates of tangent point, solution 1
//     RAZ2,DECZ2  r    spherical coordinates of tangent point, solution 2
//     N           i    number of solutions:
//                        0 = no solutions returned (note 2)
//                        1 = only the first solution is useful (note 3)
//                        2 = both solutions are useful (note 3)
//
//  Notes:
//
//  1  The RAZ1 and RAZ2 values are returned in the range 0-2pi.
//
//  2  Cases where there is no solution can only arise near the poles.
//     For example, it is clearly impossible for a star at the pole
//     itself to have a non-zero XI value, and hence it is
//     meaningless to ask where the tangent point would have to be
//     to bring about this combination of XI and DEC.
//
//  3  Also near the poles, cases can arise where there are two useful
//     solutions.  The argument N indicates whether the second of the
//     two solutions returned is useful.  N=1 indicates only one useful
//     solution, the usual case;  under these circumstances, the second
//     solution corresponds to the "over-the-pole" case, and this is
//     reflected in the values of RAZ2 and DECZ2 which are returned.
//
//  4  The DECZ1 and DECZ2 values are returned in the range +/-pi, but
//     in the usual, non-pole-crossing, case, the range is +/-pi/2.
//
//  5  This routine is the spherical equivalent of the routine sla_DTPV2C.
//
//  Called:  sla_RANORM
//
//  P.T.Wallace   Starlink   5 June 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct tps2c 
{
float RAZ1;float DECZ1;float RAZ2;float DECZ2;int N;

  tps2c( const float XI,const float ETA,const float RA,const float DEC )
  {
   sla_tps2c_( &XI,&ETA,&RA,&DEC,&RAZ1,&DECZ1,&RAZ2,&DECZ2,&N );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RAZ1,DECZ1,RAZ2,DECZ2,N : " << RAZ1<<" "<<DECZ1<<" "<<RAZ2<<" "<<DECZ2<<" "<<N << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const tps2c& o ) { return s << o.__str__(); }

//     - - - - - -
//      F K 4 2 5
//     - - - - - -
//
//  Convert B1950.0 FK4 star data to J2000.0 FK5 (double precision)
//
//  This routine converts stars from the old, Bessel-Newcomb, FK4
//  system to the new, IAU 1976, FK5, Fricke system.  The precepts
//  of Smith et al (Ref 1) are followed, using the implementation
//  by Yallop et al (Ref 2) of a matrix method due to Standish.
//  Kinoshita's development of Andoyer's post-Newcomb precession is
//  used.  The numerical constants from Seidelmann et al (Ref 3) are
//  used canonically.
//
//  Given:  (all B1950.0,FK4)
//     R1950,D1950     dp    B1950.0 RA,Dec (rad)
//     DR1950,DD1950   dp    B1950.0 proper motions (rad/trop.yr)
//     P1950           dp    parallax (arcsec)
//     V1950           dp    radial velocity (km/s, +ve = moving away)
//
//  Returned:  (all J2000.0,FK5)
//     R2000,D2000     dp    J2000.0 RA,Dec (rad)
//     DR2000,DD2000   dp    J2000.0 proper motions (rad/Jul.yr)
//     P2000           dp    parallax (arcsec)
//     V2000           dp    radial velocity (km/s, +ve = moving away)
//
//  Notes:
//
//  1)  The proper motions in RA are dRA/dt rather than
//      cos(Dec)*dRA/dt, and are per year rather than per century.
//
//  2)  Conversion from Besselian epoch 1950.0 to Julian epoch
//      2000.0 only is provided for.  Conversions involving other
//      epochs will require use of the appropriate precession,
//      proper motion, and E-terms routines before and/or
//      after FK425 is called.
//
//  3)  In the FK4 catalogue the proper motions of stars within
//      10 degrees of the poles do not embody the differential
//      E-term effect and should, strictly speaking, be handled
//      in a different manner from stars outside these regions.
//      However, given the general lack of homogeneity of the star
//      data available for routine astrometry, the difficulties of
//      handling positions that may have been determined from
//      astrometric fields spanning the polar and non-polar regions,
//      the likelihood that the differential E-terms effect was not
//      taken into account when allowing for proper motion in past
//      astrometry, and the undesirability of a discontinuity in
//      the algorithm, the decision has been made in this routine to
//      include the effect of differential E-terms on the proper
//      motions for all stars, whether polar or not.  At epoch 2000,
//      and measuring on the sky rather than in terms of dRA, the
//      errors resulting from this simplification are less than
//      1 milliarcsecond in position and 1 milliarcsecond per
//      century in proper motion.
//
//  References:
//
//     1  Smith, C.A. et al, 1989.  "The transformation of astrometric
//        catalog systems to the equinox J2000.0".  Astron.J. 97, 265.
//
//     2  Yallop, B.D. et al, 1989.  "Transformation of mean star places
//        from FK4 B1950.0 to FK5 J2000.0 using matrices in 6-space".
//        Astron.J. 97, 274.
//
//     3  Seidelmann, P.K. (ed), 1992.  "Explanatory Supplement to
//        the Astronomical Almanac", ISBN 0-935702-68-7.
//
//  P.T.Wallace   Starlink   19 December 1993
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct fk425 
{
double R2000;double D2000;double DR2000;double DD2000;double P2000;double V2000;

  fk425( const double R1950,const double D1950,const double DR1950,const double DD1950,const double P1950,const double V1950 )
  {
   sla_fk425_( &R1950,&D1950,&DR1950,&DD1950,&P1950,&V1950,&R2000,&D2000,&DR2000,&DD2000,&P2000,&V2000 );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "R2000,D2000,DR2000,DD2000,P2000,V2000 : " << R2000<<" "<<D2000<<" "<<DR2000<<" "<<DD2000<<" "<<P2000<<" "<<V2000 << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const fk425& o ) { return s << o.__str__(); }

//     - - - - - -
//      D V 2 T P
//     - - - - - -
//
//  Given the direction cosines of a star and of the tangent point,
//  determine the star's tangent-plane coordinates.
//
//  (double precision)
//
//  Given:
//     V         d(3)    direction cosines of star
//     V0        d(3)    direction cosines of tangent point
//
//  Returned:
//     XI,ETA    d       tangent plane coordinates of star
//     J         i       status:   0 = OK
//                                 1 = error, star too far from axis
//                                 2 = error, antistar on tangent plane
//                                 3 = error, antistar too far from axis
//
//  Notes:
//
//  1  If vector V0 is not of unit length, or if vector V is of zero
//     length, the results will be wrong.
//
//  2  If V0 points at a pole, the returned XI,ETA will be based on the
//     arbitrary assumption that the RA of the tangent point is zero.
//
//  3  This routine is the Cartesian equivalent of the routine sla_DS2TP.
//
//  P.T.Wallace   Starlink   27 November 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct dv2tp 
{
double XI;double ETA;int J;

  dv2tp( const double V[3],const double V0[3] )
  {
   sla_dv2tp_( V,V0,&XI,&ETA,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "XI,ETA,J : " << XI<<" "<<ETA<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dv2tp& o ) { return s << o.__str__(); }

//     - - - - -
//      T P 2 S
//     - - - - -
//
//  Transform tangent plane coordinates into spherical
//  (single precision)
//
//  Given:
//     XI,ETA      real  tangent plane rectangular coordinates
//     RAZ,DECZ    real  spherical coordinates of tangent point
//
//  Returned:
//     RA,DEC      real  spherical coordinates (0-2pi,+/-pi/2)
//
//  Called:        sla_RANORM
//
//  P.T.Wallace   Starlink   24 July 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct tp2s 
{
float RA;float DEC;

  tp2s( const float XI,const float ETA,const float RAZ,const float DECZ )
  {
   sla_tp2s_( &XI,&ETA,&RAZ,&DECZ,&RA,&DEC );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RA,DEC : " << RA<<" "<<DEC << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const tp2s& o ) { return s << o.__str__(); }

//     - - - - - -
//      D M O O N
//     - - - - - -
//
//  Approximate geocentric position and velocity of the Moon
//  (double precision)
//
//  Given:
//     DATE       D       TDB (loosely ET) as a Modified Julian Date
//                                                    (JD-2400000.5)
//
//  Returned:
//     PV         D(6)    Moon x,y,z,xdot,ydot,zdot, mean equator and
//                                         equinox of date (AU, AU/s)
//
//  Notes:
//
//  1  This routine is a full implementation of the algorithm
//     published by Meeus (see reference).
//
//  2  Meeus quotes accuracies of 10 arcsec in longitude, 3 arcsec in
//     latitude and 0.2 arcsec in HP (equivalent to about 20 km in
//     distance).  Comparison with JPL DE200 over the interval
//     1960-2025 gives RMS errors of 3.7 arcsec and 83 mas/hour in
//     longitude, 2.3 arcsec and 48 mas/hour in latitude, 11 km
//     and 81 mm/s in distance.  The maximum errors over the same
//     interval are 18 arcsec and 0.50 arcsec/hour in longitude,
//     11 arcsec and 0.24 arcsec/hour in latitude, 40 km and 0.29 m/s
//     in distance.
//
//  3  The original algorithm is expressed in terms of the obsolete
//     timescale Ephemeris Time.  Either TDB or TT can be used, but
//     not UT without incurring significant errors (30 arcsec at
//     the present time) due to the Moon's 0.5 arcsec/sec movement.
//
//  4  The algorithm is based on pre IAU 1976 standards.  However,
//     the result has been moved onto the new (FK5) equinox, an
//     adjustment which is in any case much smaller than the
//     intrinsic accuracy of the procedure.
//
//  5  Velocity is obtained by a complete analytical differentiation
//     of the Meeus model.
//
//  Reference:
//     Meeus, l'Astronomie, June 1984, p348.
//
//  P.T.Wallace   Starlink   22 January 1998
//
//  Copyright (C) 1998 Rutherford Appleton Laboratory
//


struct dmoon 
{
double PV[6];

  dmoon( const double DATE )
  {
   sla_dmoon_( &DATE,PV );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "PV : " << PV << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dmoon& o ) { return s << o.__str__(); }

//     - - - - - -
//      C A F 2 R
//     - - - - - -
//
//  Convert degrees, arcminutes, arcseconds to radians
//  (single precision)
//
//  Given:
//     IDEG        int       degrees
//     IAMIN       int       arcminutes
//     ASEC        real      arcseconds
//
//  Returned:
//     RAD         real      angle in radians
//     J           int       status:  0 = OK
//                                    1 = IDEG outside range 0-359
//                                    2 = IAMIN outside range 0-59
//                                    3 = ASEC outside range 0-59.999...
//
//  Notes:
//
//  1)  The result is computed even if any of the range checks
//      fail.
//
//  2)  The sign must be dealt with outside this routine.
//
//  P.T.Wallace   Starlink   23 August 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct caf2r 
{
float RAD;int J;

  caf2r( const int IDEG,const int IAMIN,const float ASEC )
  {
   sla_caf2r_( &IDEG,&IAMIN,&ASEC,&RAD,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RAD,J : " << RAD<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const caf2r& o ) { return s << o.__str__(); }

//     - - - - - -
//      E A R T H
//     - - - - - -
//
//  Approximate heliocentric position and velocity of the Earth
//
//  Given:
//     IY       I       year
//     ID       I       day in year (1 = Jan 1st)
//     FD       R       fraction of day
//
//  Returned:
//     PV       R(6)    Earth position & velocity vector
//
//  Notes:
//
//  1  The date and time is TDB (loosely ET) in a Julian calendar
//     which has been aligned to the ordinary Gregorian
//     calendar for the interval 1900 March 1 to 2100 February 28.
//     The year and day can be obtained by calling sla_CALYD or
//     sla_CLYD.
//
//  2  The Earth heliocentric 6-vector is mean equator and equinox
//     of date.  Position part, PV(1-3), is in AU;  velocity part,
//     PV(4-6), is in AU/sec.
//
//  3  Max/RMS errors 1950-2050:
//       13/5 E-5 AU = 19200/7600 km in position
//       47/26 E-10 AU/s = 0.0070/0.0039 km/s in speed
//
//  4  More accurate results are obtainable with the routines sla_EVP
//     and sla_EPV.
//
//  Last revision:   5 April 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct earth 
{
float PV[6];

  earth( const int IY,const int ID,const float FD )
  {
   sla_earth_( &IY,&ID,&FD,PV );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "PV : " << PV << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const earth& o ) { return s << o.__str__(); }

//     - - - - - - -
//      P R E N U T
//     - - - - - - -
//
//  Form the matrix of precession and nutation (SF2001)
//  (double precision)
//
//  Given:
//     EPOCH   dp         Julian Epoch for mean coordinates
//     DATE    dp         Modified Julian Date (JD-2400000.5)
//                        for true coordinates
//
//  Returned:
//     RMATPN  dp(3,3)    combined precession/nutation matrix
//
//  Called:  sla_PREC, sla_EPJ, sla_NUT, sla_DMXM
//
//  Notes:
//
//  1)  The epoch and date are TDB (loosely ET).  TT will do, or even
//      UTC.
//
//  2)  The matrix is in the sense   V(true) = RMATPN * V(mean)
//
//  Last revision:   3 December 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct prenut 
{
double RMATPN[3][3];

  prenut( const double EPOCH,const double DATE )
  {
   sla_prenut_( &EPOCH,&DATE,RMATPN );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RMATPN : " << RMATPN << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const prenut& o ) { return s << o.__str__(); }

//     - - - - - - -
//      D R A N G E
//     - - - - - - -
//
//  Normalize angle into range +/- pi  (double precision)
//
//  Given:
//     ANGLE     dp      the angle in radians
//
//  The result (double precision) is ANGLE expressed in the range +/- pi.
//
//  P.T.Wallace   Starlink   23 November 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline double drange( const double ANGLE )
{
 return sla_drange_( &ANGLE );
};
//     - - - - - -
//      X Y 2 X Y
//     - - - - - -
//
//  Transform one [X,Y] into another using a linear model of the type
//  produced by the sla_FITXY routine.
//
//  Given:
//     X1       d        x-coordinate
//     Y1       d        y-coordinate
//     COEFFS  d(6)      transformation coefficients (see note)
//
//  Returned:
//     X2       d        x-coordinate
//     Y2       d        y-coordinate
//
//  The model relates two sets of [X,Y] coordinates as follows.
//  Naming the elements of COEFFS:
//
//     COEFFS(1) = A
//     COEFFS(2) = B
//     COEFFS(3) = C
//     COEFFS(4) = D
//     COEFFS(5) = E
//     COEFFS(6) = F
//
//  the present routine performs the transformation:
//
//     X2 = A + B*X1 + C*Y1
//     Y2 = D + E*X1 + F*Y1
//
//  See also sla_FITXY, sla_PXY, sla_INVF, sla_DCMPF
//
//  P.T.Wallace   Starlink   5 December 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct xy2xy 
{
double X2;double Y2;

  xy2xy( const double X1,const double Y1,const double COEFFS[6] )
  {
   sla_xy2xy_( &X1,&Y1,COEFFS,&X2,&Y2 );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "X2,Y2 : " << X2<<" "<<Y2 << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const xy2xy& o ) { return s << o.__str__(); }

//     - - - - -
//      B E A R
//     - - - - -
//
//  Bearing (position angle) of one point on a sphere relative to another
//  (single precision)
//
//  Given:
//     A1,B1    r    spherical coordinates of one point
//     A2,B2    r    spherical coordinates of the other point
//
//  (The spherical coordinates are RA,Dec, Long,Lat etc, in radians.)
//
//  The result is the bearing (position angle), in radians, of point
//  A2,B2 as seen from point A1,B1.  It is in the range +/- pi.  If
//  A2,B2 is due east of A1,B1 the bearing is +pi/2.  Zero is returned
//  if the two points are coincident.
//
//  P.T.Wallace   Starlink   23 March 1991
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline float bear( const float A1,const float B1,const float A2,const float B2 )
{
 return sla_bear_( &A1,&B1,&A2,&B2 );
};
//     - - - - - -
//      U E 2 P V
//     - - - - - -
//
//  Heliocentric position and velocity of a planet, asteroid or comet,
//  starting from orbital elements in the "universal variables" form.
//
//  Given:
//     DATE     d       date, Modified Julian Date (JD-2400000.5)
//
//  Given and returned:
//     U        d(13)   universal orbital elements (updated; Note 1)
//
//       given    (1)   combined mass (M+m)
//         "      (2)   total energy of the orbit (alpha)
//         "      (3)   reference (osculating) epoch (t0)
//         "    (4-6)   position at reference epoch (r0)
//         "    (7-9)   velocity at reference epoch (v0)
//         "     (10)   heliocentric distance at reference epoch
//         "     (11)   r0.v0
//     returned  (12)   date (t)
//         "     (13)   universal eccentric anomaly (psi) of date
//
//  Returned:
//     PV       d(6)    position (AU) and velocity (AU/s)
//     JSTAT    i       status:  0 = OK
//                              -1 = radius vector zero
//                              -2 = failed to converge
//
//  Notes
//
//  1  The "universal" elements are those which define the orbit for the
//     purposes of the method of universal variables (see reference).
//     They consist of the combined mass of the two bodies, an epoch,
//     and the position and velocity vectors (arbitrary reference frame)
//     at that epoch.  The parameter set used here includes also various
//     quantities that can, in fact, be derived from the other
//     information.  This approach is taken to avoiding unnecessary
//     computation and loss of accuracy.  The supplementary quantities
//     are (i) alpha, which is proportional to the total energy of the
//     orbit, (ii) the heliocentric distance at epoch, (iii) the
//     outwards component of the velocity at the given epoch, (iv) an
//     estimate of psi, the "universal eccentric anomaly" at a given
//     date and (v) that date.
//
//  2  The companion routine is sla_EL2UE.  This takes the conventional
//     orbital elements and transforms them into the set of numbers
//     needed by the present routine.  A single prediction requires one
//     one call to sla_EL2UE followed by one call to the present routine;
//     for convenience, the two calls are packaged as the routine
//     sla_PLANEL.  Multiple predictions may be made by again
//     calling sla_EL2UE once, but then calling the present routine
//     multiple times, which is faster than multiple calls to sla_PLANEL.
//
//     It is not obligatory to use sla_EL2UE to obtain the parameters.
//     However, it should be noted that because sla_EL2UE performs its
//     own validation, no checks on the contents of the array U are made
//     by the present routine.
//
//  3  DATE is the instant for which the prediction is required.  It is
//     in the TT timescale (formerly Ephemeris Time, ET) and is a
//     Modified Julian Date (JD-2400000.5).
//
//  4  The universal elements supplied in the array U are in canonical
//     units (solar masses, AU and canonical days).  The position and
//     velocity are not sensitive to the choice of reference frame.  The
//     sla_EL2UE routine in fact produces coordinates with respect to the
//     J2000 equator and equinox.
//
//  5  The algorithm was originally adapted from the EPHSLA program of
//     D.H.P.Jones (private communication, 1996).  The method is based
//     on Stumpff's Universal Variables.
//
//  Reference:  Everhart, E. & Pitkin, E.T., Am.J.Phys. 51, 712, 1983.
//
//  P.T.Wallace   Starlink   22 October 2005
//
//  Copyright (C) 2005 Rutherford Appleton Laboratory
//


struct ue2pv 
{
double PV[6];int JSTAT;

  ue2pv( const double DATE,const double U[13] )
  {
   sla_ue2pv_( &DATE,U,PV,&JSTAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "PV,JSTAT : " << PV<<" "<<JSTAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const ue2pv& o ) { return s << o.__str__(); }

//     - - - - - - -
//      S U P G A L
//     - - - - - - -
//
//  Transformation from de Vaucouleurs supergalactic coordinates
//  to IAU 1958 galactic coordinates (double precision)
//
//  Given:
//     DSL,DSB     dp       supergalactic longitude and latitude
//
//  Returned:
//     DL,DB       dp       galactic longitude and latitude L2,B2
//
//  (all arguments are radians)
//
//  Called:
//     sla_DCS2C, sla_DIMXV, sla_DCC2S, sla_DRANRM, sla_DRANGE
//
//  References:
//
//     de Vaucouleurs, de Vaucouleurs, & Corwin, Second Reference
//     Catalogue of Bright Galaxies, U. Texas, page 8.
//
//     Systems & Applied Sciences Corp., Documentation for the
//     machine-readable version of the above catalogue,
//     Contract NAS 5-26490.
//
//    (These two references give different values for the galactic
//     longitude of the supergalactic origin.  Both are wrong;  the
//     correct value is L2=137.37.)
//
//  P.T.Wallace   Starlink   March 1986
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct supgal 
{
double DL;double DB;

  supgal( const double DSL,const double DSB )
  {
   sla_supgal_( &DSL,&DSB,&DL,&DB );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DL,DB : " << DL<<" "<<DB << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const supgal& o ) { return s << o.__str__(); }

//     - - - - - -
//      E P J 2 D
//     - - - - - -
//
//  Conversion of Julian Epoch to Modified Julian Date (double precision)
//
//  Given:
//     EPJ      dp       Julian Epoch
//
//  The result is the Modified Julian Date (JD - 2400000.5).
//
//  Reference:
//     Lieske,J.H., 1979. Astron.Astrophys.,73,282.
//
//  P.T.Wallace   Starlink   February 1984
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline double epj2d( const double EPJ )
{
 return sla_epj2d_( &EPJ );
};
//     - - - -
//      D A T
//     - - - -
//
//  Increment to be applied to Coordinated Universal Time UTC to give
//  International Atomic Time TAI (double precision)
//
//  Given:
//     UTC      d      UTC date as a modified JD (JD-2400000.5)
//
//  Result:  TAI-UTC in seconds
//
//  Notes:
//
//  1  The UTC is specified to be a date rather than a time to indicate
//     that care needs to be taken not to specify an instant which lies
//     within a leap second.  Though in most cases UTC can include the
//     fractional part, correct behaviour on the day of a leap second
//     can only be guaranteed up to the end of the second 23:59:59.
//
//  2  For epochs from 1961 January 1 onwards, the expressions from the
//     file ftp://maia.usno.navy.mil/ser7/tai-utc.dat are used.
//
//  3  The 5ms time step at 1961 January 1 is taken from 2.58.1 (p87) of
//     the 1992 Explanatory Supplement.
//
//  4  UTC began at 1960 January 1.0 (JD 2436934.5) and it is improper
//     to call the routine with an earlier epoch.  However, if this
//     is attempted, the TAI-UTC expression for the year 1960 is used.
//
//
//     :-----------------------------------------:
//     :                                         :
//     :                IMPORTANT                :
//     :                                         :
//     :  This routine must be updated on each   :
//     :     occasion that a leap second is      :
//     :                announced                :
//     :                                         :
//     :  Latest leap second:  2016 December 31  :
//     :                                         :
//     :-----------------------------------------:
//
//  Last revision:   03 October 2016
//
//  Copyright P.T.Wallace.  All rights reserved.
//


inline double dat( const double UTC )
{
 return sla_dat_( &UTC );
};
//     - - - - - -
//      D R 2 A F
//     - - - - - -
//
//  Convert an angle in radians to degrees, arcminutes, arcseconds
//  (double precision)
//
//  Given:
//     NDP      i      number of decimal places of arcseconds
//     ANGLE    d      angle in radians
//
//  Returned:
//     SIGN     c      '+' or '-'
//     IDMSF    i(4)   degrees, arcminutes, arcseconds, fraction
//
//  Notes:
//
//     1)  NDP less than zero is interpreted as zero.
//
//     2)  The largest useful value for NDP is determined by the size
//         of ANGLE, the format of DOUBLE PRECISION floating-point
//         numbers on the target machine, and the risk of overflowing
//         IDMSF(4).  On some architectures, for ANGLE up to 2pi, the
//         available floating-point precision corresponds roughly to
//         NDP=12.  However, the practical limit is NDP=9, set by the
//         capacity of a typical 32-bit IDMSF(4).
//
//     3)  The absolute value of ANGLE may exceed 2pi.  In cases where it
//         does not, it is up to the caller to test for and handle the
//         case where ANGLE is very nearly 2pi and rounds up to 360 deg,
//         by testing for IDMSF(1)=360 and setting IDMSF(1-4) to zero.
//
//  Called:  sla_DD2TF
//
//  Last revision:   26 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct dr2af 
{
char SIGN;int IDMSF[4];

  dr2af( const int NDP,const double ANGLE )
  {
   sla_dr2af_( &NDP,&ANGLE,&SIGN,IDMSF );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "SIGN,IDMSF : " << SIGN<<" "<<IDMSF << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dr2af& o ) { return s << o.__str__(); }

//     - - - - - -
//      D S E P V
//     - - - - - -
//
//  Angle between two vectors.
//
//  (double precision)
//
//  Given:
//     V1      d(3)    first vector
//     V2      d(3)    second vector
//
//  The result is the angle, in radians, between the two vectors.  It
//  is always positive.
//
//  Notes:
//
//  1  There is no requirement for the vectors to be unit length.
//
//  2  If either vector is null, zero is returned.
//
//  3  The simplest formulation would use dot product alone.  However,
//     this would reduce the accuracy for angles near zero and pi.  The
//     algorithm uses both cross product and dot product, which maintains
//     accuracy for all sizes of angle.
//
//  Called:  sla_DVXV, sla_DVN, sla_DVDV
//
//  Last revision:   14 June 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


inline double dsepv( const double V1[3],const double V2[3] )
{
 return sla_dsepv_( V1,V2 );
};
//     - - - - - -
//      A D D E T
//     - - - - - -
//
//  Add the E-terms (elliptic component of annual aberration)
//  to a pre IAU 1976 mean place to conform to the old
//  catalogue convention (double precision)
//
//  Given:
//     RM,DM     dp     RA,Dec (radians) without E-terms
//     EQ        dp     Besselian epoch of mean equator and equinox
//
//  Returned:
//     RC,DC     dp     RA,Dec (radians) with E-terms included
//
//  Note:
//
//     Most star positions from pre-1984 optical catalogues (or
//     derived from astrometry using such stars) embody the
//     E-terms.  If it is necessary to convert a formal mean
//     place (for example a pulsar timing position) to one
//     consistent with such a star catalogue, then the RA,Dec
//     should be adjusted using this routine.
//
//  Reference:
//     Explanatory Supplement to the Astronomical Ephemeris,
//     section 2D, page 48.
//
//  Called:  sla_ETRMS, sla_DCS2C, sla_DCC2S, sla_DRANRM, sla_DRANGE
//
//  P.T.Wallace   Starlink   18 March 1999
//
//  Copyright (C) 1999 Rutherford Appleton Laboratory
//


struct addet 
{
double RC;double DC;

  addet( const double RM,const double DM,const double EQ )
  {
   sla_addet_( &RM,&DM,&EQ,&RC,&DC );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RC,DC : " << RC<<" "<<DC << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const addet& o ) { return s << o.__str__(); }

//     - - - - -
//      R E F V
//     - - - - -
//
//  Adjust an unrefracted Cartesian vector to include the effect of
//  atmospheric refraction, using the simple A tan Z + B tan**3 Z
//  model.
//
//  Given:
//    VU    dp    unrefracted position of the source (Az/El 3-vector)
//    REFA  dp    tan Z coefficient (radian)
//    REFB  dp    tan**3 Z coefficient (radian)
//
//  Returned:
//    VR    dp    refracted position of the source (Az/El 3-vector)
//
//  Notes:
//
//  1  This routine applies the adjustment for refraction in the
//     opposite sense to the usual one - it takes an unrefracted
//     (in vacuo) position and produces an observed (refracted)
//     position, whereas the A tan Z + B tan**3 Z model strictly
//     applies to the case where an observed position is to have the
//     refraction removed.  The unrefracted to refracted case is
//     harder, and requires an inverted form of the text-book
//     refraction models;  the algorithm used here is equivalent to
//     one iteration of the Newton-Raphson method applied to the above
//     formula.
//
//  2  Though optimized for speed rather than precision, the present
//     routine achieves consistency with the refracted-to-unrefracted
//     A tan Z + B tan**3 Z model at better than 1 microarcsecond within
//     30 degrees of the zenith and remains within 1 milliarcsecond to
//     beyond ZD 70 degrees.  The inherent accuracy of the model is, of
//     course, far worse than this - see the documentation for sla_REFCO
//     for more information.
//
//  3  At low elevations (below about 3 degrees) the refraction
//     correction is held back to prevent arithmetic problems and
//     wildly wrong results.  For optical/IR wavelengths, over a wide
//     range of observer heights and corresponding temperatures and
//     pressures, the following levels of accuracy (arcsec, worst case)
//     are achieved, relative to numerical integration through a model
//     atmosphere:
//
//              ZD    error
//
//              80      0.7
//              81      1.3
//              82      2.5
//              83      5
//              84     10
//              85     20
//              86     55
//              87    160
//              88    360
//              89    640
//              90   1100
//              91   1700         } relevant only to
//              92   2600         } high-elevation sites
//
//     The results for radio are slightly worse over most of the range,
//     becoming significantly worse below ZD=88 and unusable beyond
//     ZD=90.
//
//  4  See also the routine sla_REFZ, which performs the adjustment to
//     the zenith distance rather than in Cartesian Az/El coordinates.
//     The present routine is faster than sla_REFZ and, except very low down,
//     is equally accurate for all practical purposes.  However, beyond
//     about ZD 84 degrees sla_REFZ should be used, and for the utmost
//     accuracy iterative use of sla_REFRO should be considered.
//
//  P.T.Wallace   Starlink   10 April 2004
//
//  Copyright (C) 2004 Rutherford Appleton Laboratory
//


struct refv 
{
double VR;

  refv( const double VU,const double REFA,const double REFB )
  {
   sla_refv_( &VU,&REFA,&REFB,&VR );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "VR : " << VR << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const refv& o ) { return s << o.__str__(); }

//     - - - - -
//      D S E P
//     - - - - -
//
//  Angle between two points on a sphere.
//
//  (double precision)
//
//  Given:
//     A1,B1    d     spherical coordinates of one point
//     A2,B2    d     spherical coordinates of the other point
//
//  (The spherical coordinates are [RA,Dec], [Long,Lat] etc, in radians.)
//
//  The result is the angle, in radians, between the two points.  It
//  is always positive.
//
//  Called:  sla_DCS2C, sla_DSEPV
//
//  Last revision:   7 May 2000
//
//  Copyright P.T.Wallace.  All rights reserved.
//


inline double dsep( const double A1,const double B1,const double A2,const double B2 )
{
 return sla_dsep_( &A1,&B1,&A2,&B2 );
};
//     - - - - -
//      A T M T
//     - - - - -
//
//  Internal routine used by REFRO
//
//  Refractive index and derivative with respect to height for the
//  troposphere.
//
//  Given:
//    R0      d    height of observer from centre of the Earth (metre)
//    T0      d    temperature at the observer (K)
//    ALPHA   d    alpha          )
//    GAMM2   d    gamma minus 2  ) see HMNAO paper
//    DELM2   d    delta minus 2  )
//    C1      d    useful term  )
//    C2      d    useful term  )
//    C3      d    useful term  ) see source
//    C4      d    useful term  ) of sla_REFRO
//    C5      d    useful term  )
//    C6      d    useful term  )
//    R       d    current distance from the centre of the Earth (metre)
//
//  Returned:
//    T       d    temperature at R (K)
//    DN      d    refractive index at R
//    RDNDR   d    R * rate the refractive index is changing at R
//
//  Note that in the optical case C5 and C6 are zero.
//
//  Last revision:   26 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct _atmt 
{
double T;double DN;double RDNDR;

  _atmt( const double R0,const double T0,const double ALPHA,const double GAMM2,const double DELM2,const double C1,const double C2,const double C3,const double C4,const double C5,const double C6,const double R )
  {
   sla__atmt_( &R0,&T0,&ALPHA,&GAMM2,&DELM2,&C1,&C2,&C3,&C4,&C5,&C6,&R,&T,&DN,&RDNDR );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "T,DN,RDNDR : " << T<<" "<<DN<<" "<<RDNDR << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const _atmt& o ) { return s << o.__str__(); }

//     - - - - - -
//      C C 6 2 S
//     - - - - - -
//
//  Conversion of position & velocity in Cartesian coordinates
//  to spherical coordinates (single precision)
//
//  Given:
//     V      r(6)   Cartesian position & velocity vector
//
//  Returned:
//     A      r      longitude (radians)
//     B      r      latitude (radians)
//     R      r      radial coordinate
//     AD     r      longitude derivative (radians per unit time)
//     BD     r      latitude derivative (radians per unit time)
//     RD     r      radial derivative
//
//  P.T.Wallace   Starlink   28 April 1996
//
//  Copyright (C) 1996 Rutherford Appleton Laboratory
//


struct cc62s 
{
float A;float B;float R;float AD;float BD;float RD;

  cc62s( const float V[6] )
  {
   sla_cc62s_( V,&A,&B,&R,&AD,&BD,&RD );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "A,B,R,AD,BD,RD : " << A<<" "<<B<<" "<<R<<" "<<AD<<" "<<BD<<" "<<RD << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const cc62s& o ) { return s << o.__str__(); }

//     - - - - - -
//      S U B E T
//     - - - - - -
//
//  Remove the E-terms (elliptic component of annual aberration)
//  from a pre IAU 1976 catalogue RA,Dec to give a mean place
//  (double precision)
//
//  Given:
//     RC,DC     dp     RA,Dec (radians) with E-terms included
//     EQ        dp     Besselian epoch of mean equator and equinox
//
//  Returned:
//     RM,DM     dp     RA,Dec (radians) without E-terms
//
//  Called:
//     sla_ETRMS, sla_DCS2C, sla_,DVDV, sla_DCC2S, sla_DRANRM
//
//  Explanation:
//     Most star positions from pre-1984 optical catalogues (or
//     derived from astrometry using such stars) embody the
//     E-terms.  This routine converts such a position to a
//     formal mean place (allowing, for example, comparison with a
//     pulsar timing position).
//
//  Reference:
//     Explanatory Supplement to the Astronomical Ephemeris,
//     section 2D, page 48.
//
//  P.T.Wallace   Starlink   10 May 1990
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct subet 
{
double RM;double DM;

  subet( const double RC,const double DC,const double EQ )
  {
   sla_subet_( &RC,&DC,&EQ,&RM,&DM );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RM,DM : " << RM<<" "<<DM << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const subet& o ) { return s << o.__str__(); }

//     - - - - -
//      C L D J
//     - - - - -
//
//  Gregorian Calendar to Modified Julian Date
//
//  Given:
//     IY,IM,ID     int    year, month, day in Gregorian calendar
//
//  Returned:
//     DJM          dp     modified Julian Date (JD-2400000.5) for 0 hrs
//     J            int    status:
//                           0 = OK
//                           1 = bad year   (MJD not computed)
//                           2 = bad month  (MJD not computed)
//                           3 = bad day    (MJD computed)
//
//  The year must be -4699 (i.e. 4700BC) or later.
//
//  The algorithm is adapted from Hatcher 1984 (QJRAS 25, 53-55).
//
//  Last revision:   27 July 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct cldj 
{
double DJM;int J;

  cldj( const int IY,const int IM,const int ID )
  {
   sla_cldj_( &IY,&IM,&ID,&DJM,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DJM,J : " << DJM<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const cldj& o ) { return s << o.__str__(); }

//     - - - - - -
//      D T F 2 R
//     - - - - - -
//
//  Convert hours, minutes, seconds to radians (double precision)
//
//  Given:
//     IHOUR       int       hours
//     IMIN        int       minutes
//     SEC         dp        seconds
//
//  Returned:
//     RAD         dp        angle in radians
//     J           int       status:  0 = OK
//                                    1 = IHOUR outside range 0-23
//                                    2 = IMIN outside range 0-59
//                                    3 = SEC outside range 0-59.999...
//
//  Called:
//     sla_DTF2D
//
//  Notes:
//
//     1)  The result is computed even if any of the range checks fail.
//
//     2)  The sign must be dealt with outside this routine.
//
//  P.T.Wallace   Starlink   July 1984
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct dtf2r 
{
double RAD;int J;

  dtf2r( const int IHOUR,const int IMIN,const double SEC )
  {
   sla_dtf2r_( &IHOUR,&IMIN,&SEC,&RAD,&J );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RAD,J : " << RAD<<" "<<J << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dtf2r& o ) { return s << o.__str__(); }

//     - - - -
//      A O P
//     - - - -
//
//  Apparent to observed place, for sources distant from the solar
//  system.
//
//  Given:
//     RAP    d      geocentric apparent right ascension
//     DAP    d      geocentric apparent declination
//     DATE   d      UTC date/time (Modified Julian Date, JD-2400000.5)
//     DUT    d      delta UT:  UT1-UTC (UTC seconds)
//     ELONGM d      mean longitude of the observer (radians, east +ve)
//     PHIM   d      mean geodetic latitude of the observer (radians)
//     HM     d      observer's height above sea level (metres)
//     XP     d      polar motion x-coordinate (radians)
//     YP     d      polar motion y-coordinate (radians)
//     TDK    d      local ambient temperature (K; std=273.15D0)
//     PMB    d      local atmospheric pressure (mb; std=1013.25D0)
//     RH     d      local relative humidity (in the range 0D0-1D0)
//     WL     d      effective wavelength (micron, e.g. 0.55D0)
//     TLR    d      tropospheric lapse rate (K/metre, e.g. 0.0065D0)
//
//  Returned:
//     AOB    d      observed azimuth (radians: N=0,E=90)
//     ZOB    d      observed zenith distance (radians)
//     HOB    d      observed Hour Angle (radians)
//     DOB    d      observed Declination (radians)
//     ROB    d      observed Right Ascension (radians)
//
//  Notes:
//
//   1)  This routine returns zenith distance rather than elevation
//       in order to reflect the fact that no allowance is made for
//       depression of the horizon.
//
//   2)  The accuracy of the result is limited by the corrections for
//       refraction.  Providing the meteorological parameters are
//       known accurately and there are no gross local effects, the
//       predicted apparent RA,Dec should be within about 0.1 arcsec
//       for a zenith distance of less than 70 degrees.  Even at a
//       topocentric zenith distance of 90 degrees, the accuracy in
//       elevation should be better than 1 arcmin;  useful results
//       are available for a further 3 degrees, beyond which the
//       sla_REFRO routine returns a fixed value of the refraction.
//       The complementary routines sla_AOP (or sla_AOPQK) and sla_OAP
//       (or sla_OAPQK) are self-consistent to better than 1 micro-
//       arcsecond all over the celestial sphere.
//
//   3)  It is advisable to take great care with units, as even
//       unlikely values of the input parameters are accepted and
//       processed in accordance with the models used.
//
//   4)  "Apparent" place means the geocentric apparent right ascension
//       and declination, which is obtained from a catalogue mean place
//       by allowing for space motion, parallax, precession, nutation,
//       annual aberration, and the Sun's gravitational lens effect.  For
//       star positions in the FK5 system (i.e. J2000), these effects can
//       be applied by means of the sla_MAP etc routines.  Starting from
//       other mean place systems, additional transformations will be
//       needed;  for example, FK4 (i.e. B1950) mean places would first
//       have to be converted to FK5, which can be done with the
//       sla_FK425 etc routines.
//
//   5)  "Observed" Az,El means the position that would be seen by a
//       perfect theodolite located at the observer.  This is obtained
//       from the geocentric apparent RA,Dec by allowing for Earth
//       orientation and diurnal aberration, rotating from equator
//       to horizon coordinates, and then adjusting for refraction.
//       The HA,Dec is obtained by rotating back into equatorial
//       coordinates, using the geodetic latitude corrected for polar
//       motion, and is the position that would be seen by a perfect
//       equatorial located at the observer and with its polar axis
//       aligned to the Earth's axis of rotation (n.b. not to the
//       refracted pole).  Finally, the RA is obtained by subtracting
//       the HA from the local apparent ST.
//
//   6)  To predict the required setting of a real telescope, the
//       observed place produced by this routine would have to be
//       adjusted for the tilt of the azimuth or polar axis of the
//       mounting (with appropriate corrections for mount flexures),
//       for non-perpendicularity between the mounting axes, for the
//       position of the rotator axis and the pointing axis relative
//       to it, for tube flexure, for gear and encoder errors, and
//       finally for encoder zero points.  Some telescopes would, of
//       course, exhibit other properties which would need to be
//       accounted for at the appropriate point in the sequence.
//
//   7)  This routine takes time to execute, due mainly to the
//       rigorous integration used to evaluate the refraction.
//       For processing multiple stars for one location and time,
//       call sla_AOPPA once followed by one call per star to sla_AOPQK.
//       Where a range of times within a limited period of a few hours
//       is involved, and the highest precision is not required, call
//       sla_AOPPA once, followed by a call to sla_AOPPAT each time the
//       time changes, followed by one call per star to sla_AOPQK.
//
//   8)  The DATE argument is UTC expressed as an MJD.  This is,
//       strictly speaking, wrong, because of leap seconds.  However,
//       as long as the delta UT and the UTC are consistent there
//       are no difficulties, except during a leap second.  In this
//       case, the start of the 61st second of the final minute should
//       begin a new MJD day and the old pre-leap delta UT should
//       continue to be used.  As the 61st second completes, the MJD
//       should revert to the start of the day as, simultaneously,
//       the delta UTC changes by one second to its post-leap new value.
//
//   9)  The delta UT (UT1-UTC) is tabulated in IERS circulars and
//       elsewhere.  It increases by exactly one second at the end of
//       each UTC leap second, introduced in order to keep delta UT
//       within +/- 0.9 seconds.
//
//  10)  IMPORTANT -- TAKE CARE WITH THE LONGITUDE SIGN CONVENTION.
//       The longitude required by the present routine is east-positive,
//       in accordance with geographical convention (and right-handed).
//       In particular, note that the longitudes returned by the
//       sla_OBS routine are west-positive, following astronomical
//       usage, and must be reversed in sign before use in the present
//       routine.
//
//  11)  The polar coordinates XP,YP can be obtained from IERS
//       circulars and equivalent publications.  The maximum amplitude
//       is about 0.3 arcseconds.  If XP,YP values are unavailable,
//       use XP=YP=0D0.  See page B60 of the 1988 Astronomical Almanac
//       for a definition of the two angles.
//
//  12)  The height above sea level of the observing station, HM,
//       can be obtained from the Astronomical Almanac (Section J
//       in the 1988 edition), or via the routine sla_OBS.  If P,
//       the pressure in millibars, is available, an adequate
//       estimate of HM can be obtained from the expression
//
//             HM ~ -29.3D0*TSL*LOG(P/1013.25D0).
//
//       where TSL is the approximate sea-level air temperature in K
//       (see Astrophysical Quantities, C.W.Allen, 3rd edition,
//       section 52).  Similarly, if the pressure P is not known,
//       it can be estimated from the height of the observing
//       station, HM, as follows:
//
//             P ~ 1013.25D0*EXP(-HM/(29.3D0*TSL)).
//
//       Note, however, that the refraction is nearly proportional to the
//       pressure and that an accurate P value is important for precise
//       work.
//
//  13)  The azimuths etc produced by the present routine are with
//       respect to the celestial pole.  Corrections to the terrestrial
//       pole can be computed using sla_POLMO.
//
//  Called:  sla_AOPPA, sla_AOPQK
//
//  Last revision:   2 December 2005
//
//  Copyright P.T.Wallace.   All rights reserved.
//


struct aop 
{
double AOB;double ZOB;double HOB;double DOB;double ROB;

  aop( const double RAP,const double DAP,const double DATE,const double DUT,const double ELONGM,const double PHIM,const double HM,const double XP,const double YP,const double TDK,const double PMB,const double RH,const double WL,const double TLR )
  {
   sla_aop_( &RAP,&DAP,&DATE,&DUT,&ELONGM,&PHIM,&HM,&XP,&YP,&TDK,&PMB,&RH,&WL,&TLR,&AOB,&ZOB,&HOB,&DOB,&ROB );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "AOB,ZOB,HOB,DOB,ROB : " << AOB<<" "<<ZOB<<" "<<HOB<<" "<<DOB<<" "<<ROB << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const aop& o ) { return s << o.__str__(); }

//     - - - - - - -
//      R V E R O T
//     - - - - - - -
//
//  Velocity component in a given direction due to Earth rotation
//  (single precision)
//
//  Given:
//     PHI     real    latitude of observing station (geodetic)
//     RA,DA   real    apparent RA,DEC
//     ST      real    local apparent sidereal time
//
//  PHI, RA, DEC and ST are all in radians.
//
//  Result:
//     Component of Earth rotation in direction RA,DA (km/s)
//
//  Sign convention:
//     The result is +ve when the observatory is receding from the
//     given point on the sky.
//
//  Accuracy:
//     The simple algorithm used assumes a spherical Earth, of
//     a radius chosen to give results accurate to about 0.0005 km/s
//     for observing stations at typical latitudes and heights.  For
//     applications requiring greater precision, use the routine
//     sla_PVOBS.
//
//  P.T.Wallace   Starlink   20 July 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline float rverot( const float PHI,const float RA,const float DA,const float ST )
{
 return sla_rverot_( &PHI,&RA,&DA,&ST );
};
//     - - - - - - -
//      R D P L A N
//     - - - - - - -
//
//  Approximate topocentric apparent RA,Dec of a planet, and its
//  angular diameter.
//
//  Given:
//     DATE        d       MJD of observation (JD - 2400000.5)
//     NP          i       planet: 1 = Mercury
//                                 2 = Venus
//                                 3 = Moon
//                                 4 = Mars
//                                 5 = Jupiter
//                                 6 = Saturn
//                                 7 = Uranus
//                                 8 = Neptune
//                                 9 = Pluto
//                              else = Sun
//     ELONG,PHI   d       observer's east longitude and geodetic
//                                               latitude (radians)
//
//  Returned:
//     RA,DEC      d        RA, Dec (topocentric apparent, radians)
//     DIAM        d        angular diameter (equatorial, radians)
//
//  Notes:
//
//  1  The date is in a dynamical timescale (TDB, formerly ET) and is
//     in the form of a Modified Julian Date (JD-2400000.5).  For all
//     practical purposes, TT can be used instead of TDB, and for many
//     applications UT will do (except for the Moon).
//
//  2  The longitude and latitude allow correction for geocentric
//     parallax.  This is a major effect for the Moon, but in the
//     context of the limited accuracy of the present routine its
//     effect on planetary positions is small (negligible for the
//     outer planets).  Geocentric positions can be generated by
//     appropriate use of the routines sla_DMOON and sla_PLANET.
//
//  3  The direction accuracy (arcsec, 1000-3000AD) is of order:
//
//            Sun              5
//            Mercury          2
//            Venus           10
//            Moon            30
//            Mars            50
//            Jupiter         90
//            Saturn          90
//            Uranus          90
//            Neptune         10
//            Pluto            1   (1885-2099AD only)
//
//     The angular diameter accuracy is about 0.4% for the Moon,
//     and 0.01% or better for the Sun and planets.
//
//  See the sla_PLANET routine for references.
//
//  Called: sla_GMST, sla_DT, sla_EPJ, sla_DMOON, sla_PVOBS, sla_PRENUT,
//          sla_PLANET, sla_DMXV, sla_DCC2S, sla_DRANRM
//
//  P.T.Wallace   Starlink   26 May 1997
//
//  Copyright (C) 1997 Rutherford Appleton Laboratory
//


struct rdplan 
{
double RA;double DEC;double DIAM;

  rdplan( const double DATE,const int NP,const double ELONG,const double PHI )
  {
   sla_rdplan_( &DATE,&NP,&ELONG,&PHI,&RA,&DEC,&DIAM );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RA,DEC,DIAM : " << RA<<" "<<DEC<<" "<<DIAM << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const rdplan& o ) { return s << o.__str__(); }

//     - - - - - -
//      D B J I N
//     - - - - - -
//
//  Convert free-format input into double precision floating point,
//  using DFLTIN but with special syntax extensions.
//
//  The purpose of the syntax extensions is to help cope with mixed
//  FK4 and FK5 data.  In addition to the syntax accepted by DFLTIN,
//  the following two extensions are recognized by DBJIN:
//
//     1)  A valid non-null field preceded by the character 'B'
//         (or 'b') is accepted.
//
//     2)  A valid non-null field preceded by the character 'J'
//         (or 'j') is accepted.
//
//  The calling program is notified of the incidence of either of these
//  extensions through an supplementary status argument.  The rest of
//  the arguments are as for DFLTIN.
//
//  Given:
//     STRING      char       string containing field to be decoded
//     NSTRT       int        pointer to 1st character of field in string
//
//  Returned:
//     NSTRT       int        incremented
//     DRESLT      double     result
//     J1          int        DFLTIN status: -1 = -OK
//                                            0 = +OK
//                                           +1 = null field
//                                           +2 = error
//     J2          int        syntax flag:  0 = normal DFLTIN syntax
//                                         +1 = 'B' or 'b'
//                                         +2 = 'J' or 'j'
//
//  Called:  sla_DFLTIN
//
//  For details of the basic syntax, see sla_DFLTIN.
//
//  P.T.Wallace   Starlink   23 November 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct dbjin 
{
double DRESLT;int J1;int J2;

  dbjin( const char STRING,int NSTRT )
  {
   sla_dbjin_( &STRING,&NSTRT,&DRESLT,&J1,&J2 );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "DRESLT,J1,J2 : " << DRESLT<<" "<<J1<<" "<<J2 << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dbjin& o ) { return s << o.__str__(); }

//     - - - - - -
//      T P V 2 C
//     - - - - - -
//
//  Given the tangent-plane coordinates of a star and its direction
//  cosines, determine the direction cosines of the tangent-point.
//
//  (single precision)
//
//  Given:
//     XI,ETA    r       tangent plane coordinates of star
//     V         r(3)    direction cosines of star
//
//  Returned:
//     V01       r(3)    direction cosines of tangent point, solution 1
//     V02       r(3)    direction cosines of tangent point, solution 2
//     N         i       number of solutions:
//                         0 = no solutions returned (note 2)
//                         1 = only the first solution is useful (note 3)
//                         2 = both solutions are useful (note 3)
//
//  Notes:
//
//  1  The vector V must be of unit length or the result will be wrong.
//
//  2  Cases where there is no solution can only arise near the poles.
//     For example, it is clearly impossible for a star at the pole
//     itself to have a non-zero XI value, and hence it is meaningless
//     to ask where the tangent point would have to be.
//
//  3  Also near the poles, cases can arise where there are two useful
//     solutions.  The argument N indicates whether the second of the
//     two solutions returned is useful.  N=1 indicates only one useful
//     solution, the usual case;  under these circumstances, the second
//     solution can be regarded as valid if the vector V02 is interpreted
//     as the "over-the-pole" case.
//
//  4  This routine is the Cartesian equivalent of the routine sla_TPS2C.
//
//  P.T.Wallace   Starlink   5 June 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct tpv2c 
{
float V01[3];float V02[3];int N;

  tpv2c( const float XI,const float ETA,const float V[3] )
  {
   sla_tpv2c_( &XI,&ETA,V,V01,V02,&N );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "V01,V02,N : " << V01<<" "<<V02<<" "<<N << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const tpv2c& o ) { return s << o.__str__(); }

//     - - - - - -
//      O A P Q K
//     - - - - - -
//
//  Quick observed to apparent place
//
//  Given:
//     TYPE   c*(*)  type of coordinates - 'R', 'H' or 'A' (see below)
//     OB1    d      observed Az, HA or RA (radians; Az is N=0,E=90)
//     OB2    d      observed ZD or Dec (radians)
//     AOPRMS d(14)  star-independent apparent-to-observed parameters:
//
//       (1)      geodetic latitude (radians)
//       (2,3)    sine and cosine of geodetic latitude
//       (4)      magnitude of diurnal aberration vector
//       (5)      height (HM)
//       (6)      ambient temperature (T)
//       (7)      pressure (P)
//       (8)      relative humidity (RH)
//       (9)      wavelength (WL)
//       (10)     lapse rate (TLR)
//       (11,12)  refraction constants A and B (radians)
//       (13)     longitude + eqn of equinoxes + sidereal DUT (radians)
//       (14)     local apparent sidereal time (radians)
//
//  Returned:
//     RAP    d      geocentric apparent right ascension
//     DAP    d      geocentric apparent declination
//
//  Notes:
//
//  1)  Only the first character of the TYPE argument is significant.
//      'R' or 'r' indicates that OBS1 and OBS2 are the observed right
//      ascension and declination;  'H' or 'h' indicates that they are
//      hour angle (west +ve) and declination;  anything else ('A' or
//      'a' is recommended) indicates that OBS1 and OBS2 are azimuth
//      (north zero, east 90 deg) and zenith distance.  (Zenith distance
//      is used rather than elevation in order to reflect the fact that
//      no allowance is made for depression of the horizon.)
//
//  2)  The accuracy of the result is limited by the corrections for
//      refraction.  Providing the meteorological parameters are
//      known accurately and there are no gross local effects, the
//      predicted apparent RA,Dec should be within about 0.1 arcsec
//      for a zenith distance of less than 70 degrees.  Even at a
//      topocentric zenith distance of 90 degrees, the accuracy in
//      elevation should be better than 1 arcmin;  useful results
//      are available for a further 3 degrees, beyond which the
//      sla_REFRO routine returns a fixed value of the refraction.
//      The complementary routines sla_AOP (or sla_AOPQK) and sla_OAP
//      (or sla_OAPQK) are self-consistent to better than 1 micro-
//      arcsecond all over the celestial sphere.
//
//  3)  It is advisable to take great care with units, as even
//      unlikely values of the input parameters are accepted and
//      processed in accordance with the models used.
//
//  5)  "Observed" Az,El means the position that would be seen by a
//      perfect theodolite located at the observer.  This is
//      related to the observed HA,Dec via the standard rotation, using
//      the geodetic latitude (corrected for polar motion), while the
//      observed HA and RA are related simply through the local
//      apparent ST.  "Observed" RA,Dec or HA,Dec thus means the
//      position that would be seen by a perfect equatorial located
//      at the observer and with its polar axis aligned to the
//      Earth's axis of rotation (n.b. not to the refracted pole).
//      By removing from the observed place the effects of
//      atmospheric refraction and diurnal aberration, the
//      geocentric apparent RA,Dec is obtained.
//
//  5)  Frequently, mean rather than apparent RA,Dec will be required,
//      in which case further transformations will be necessary.  The
//      sla_AMP etc routines will convert the apparent RA,Dec produced
//      by the present routine into an "FK5" (J2000) mean place, by
//      allowing for the Sun's gravitational lens effect, annual
//      aberration, nutation and precession.  Should "FK4" (1950)
//      coordinates be needed, the routines sla_FK524 etc will also
//      need to be applied.
//
//  6)  To convert to apparent RA,Dec the coordinates read from a
//      real telescope, corrections would have to be applied for
//      encoder zero points, gear and encoder errors, tube flexure,
//      the position of the rotator axis and the pointing axis
//      relative to it, non-perpendicularity between the mounting
//      axes, and finally for the tilt of the azimuth or polar axis
//      of the mounting (with appropriate corrections for mount
//      flexures).  Some telescopes would, of course, exhibit other
//      properties which would need to be accounted for at the
//      appropriate point in the sequence.
//
//  7)  The star-independent apparent-to-observed-place parameters
//      in AOPRMS may be computed by means of the sla_AOPPA routine.
//      If nothing has changed significantly except the time, the
//      sla_AOPPAT routine may be used to perform the requisite
//      partial recomputation of AOPRMS.
//
//  8) The azimuths etc used by the present routine are with respect
//     to the celestial pole.  Corrections from the terrestrial pole
//     can be computed using sla_POLMO.
//
//  Called:  sla_DCS2C, sla_DCC2S, sla_REFRO, sla_DRANRM
//
//  Last revision:   29 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct oapqk 
{
double RAP;double DAP;

  oapqk( const string& TYPE,const double OB1,const double OB2,const double AOPRMS[14] )
  {
   sla_oapqk_( TYPE.c_str(),_pointable<int>(TYPE.length()),&OB1,&OB2,AOPRMS,&RAP,&DAP );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RAP,DAP : " << RAP<<" "<<DAP << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const oapqk& o ) { return s << o.__str__(); }

//     - - - - - -
//      P D A 2 H
//     - - - - - -
//
//  Hour Angle corresponding to a given azimuth
//
//  (double precision)
//
//  Given:
//     P       d        latitude
//     D       d        declination
//     A       d        azimuth
//
//  Returned:
//     H1      d        hour angle:  first solution if any
//     J1      i        flag: 0 = solution 1 is valid
//     H2      d        hour angle:  second solution if any
//     J2      i        flag: 0 = solution 2 is valid
//
//  Called:  sla_DRANGE
//
//  P.T.Wallace   Starlink   6 October 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct pda2h 
{
double H1;int J1;double H2;int J2;

  pda2h( const double P,const double D,const double A )
  {
   sla_pda2h_( &P,&D,&A,&H1,&J1,&H2,&J2 );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "H1,J1,H2,J2 : " << H1<<" "<<J1<<" "<<H2<<" "<<J2 << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const pda2h& o ) { return s << o.__str__(); }

//     - - - - - -
//      A O P Q K
//     - - - - - -
//
//  Quick apparent to observed place (but see note 8, below, for
//  remarks about speed).
//
//  Given:
//     RAP    d      geocentric apparent right ascension
//     DAP    d      geocentric apparent declination
//     AOPRMS d(14)  star-independent apparent-to-observed parameters:
//
//       (1)      geodetic latitude (radians)
//       (2,3)    sine and cosine of geodetic latitude
//       (4)      magnitude of diurnal aberration vector
//       (5)      height (HM)
//       (6)      ambient temperature (T)
//       (7)      pressure (P)
//       (8)      relative humidity (RH)
//       (9)      wavelength (WL)
//       (10)     lapse rate (TLR)
//       (11,12)  refraction constants A and B (radians)
//       (13)     longitude + eqn of equinoxes + sidereal DUT (radians)
//       (14)     local apparent sidereal time (radians)
//
//  Returned:
//     AOB    d      observed azimuth (radians: N=0,E=90)
//     ZOB    d      observed zenith distance (radians)
//     HOB    d      observed Hour Angle (radians)
//     DOB    d      observed Declination (radians)
//     ROB    d      observed Right Ascension (radians)
//
//  Notes:
//
//   1)  This routine returns zenith distance rather than elevation
//       in order to reflect the fact that no allowance is made for
//       depression of the horizon.
//
//   2)  The accuracy of the result is limited by the corrections for
//       refraction.  Providing the meteorological parameters are
//       known accurately and there are no gross local effects, the
//       observed RA,Dec predicted by this routine should be within
//       about 0.1 arcsec for a zenith distance of less than 70 degrees.
//       Even at a topocentric zenith distance of 90 degrees, the
//       accuracy in elevation should be better than 1 arcmin;  useful
//       results are available for a further 3 degrees, beyond which
//       the sla_REFRO routine returns a fixed value of the refraction.
//       The complementary routines sla_AOP (or sla_AOPQK) and sla_OaAP
//       (or sla_OAPQK) are self-consistent to better than 1 micro-
//       arcsecond all over the celestial sphere.
//
//   3)  It is advisable to take great care with units, as even
//       unlikely values of the input parameters are accepted and
//       processed in accordance with the models used.
//
//   4)  "Apparent" place means the geocentric apparent right ascension
//       and declination, which is obtained from a catalogue mean place
//       by allowing for space motion, parallax, precession, nutation,
//       annual aberration, and the Sun's gravitational lens effect.  For
//       star positions in the FK5 system (i.e. J2000), these effects can
//       be applied by means of the sla_MAP etc routines.  Starting from
//       other mean place systems, additional transformations will be
//       needed;  for example, FK4 (i.e. B1950) mean places would first
//       have to be converted to FK5, which can be done with the
//       sla_FK425 etc routines.
//
//   5)  "Observed" Az,El means the position that would be seen by a
//       perfect theodolite located at the observer.  This is obtained
//       from the geocentric apparent RA,Dec by allowing for Earth
//       orientation and diurnal aberration, rotating from equator
//       to horizon coordinates, and then adjusting for refraction.
//       The HA,Dec is obtained by rotating back into equatorial
//       coordinates, using the geodetic latitude corrected for polar
//       motion, and is the position that would be seen by a perfect
//       equatorial located at the observer and with its polar axis
//       aligned to the Earth's axis of rotation (n.b. not to the
//       refracted pole).  Finally, the RA is obtained by subtracting
//       the HA from the local apparent ST.
//
//   6)  To predict the required setting of a real telescope, the
//       observed place produced by this routine would have to be
//       adjusted for the tilt of the azimuth or polar axis of the
//       mounting (with appropriate corrections for mount flexures),
//       for non-perpendicularity between the mounting axes, for the
//       position of the rotator axis and the pointing axis relative
//       to it, for tube flexure, for gear and encoder errors, and
//       finally for encoder zero points.  Some telescopes would, of
//       course, exhibit other properties which would need to be
//       accounted for at the appropriate point in the sequence.
//
//   7)  The star-independent apparent-to-observed-place parameters
//       in AOPRMS may be computed by means of the sla_AOPPA routine.
//       If nothing has changed significantly except the time, the
//       sla_AOPPAT routine may be used to perform the requisite
//       partial recomputation of AOPRMS.
//
//   8)  At zenith distances beyond about 76 degrees, the need for
//       special care with the corrections for refraction causes a
//       marked increase in execution time.  Moreover, the effect
//       gets worse with increasing zenith distance.  Adroit
//       programming in the calling application may allow the
//       problem to be reduced.  Prepare an alternative AOPRMS array,
//       computed for zero air-pressure;  this will disable the
//       refraction corrections and cause rapid execution.  Using
//       this AOPRMS array, a preliminary call to the present routine
//       will, depending on the application, produce a rough position
//       which may be enough to establish whether the full, slow
//       calculation (using the real AOPRMS array) is worthwhile.
//       For example, there would be no need for the full calculation
//       if the preliminary call had already established that the
//       source was well below the elevation limits for a particular
//       telescope.
//
//  9)   The azimuths etc produced by the present routine are with
//       respect to the celestial pole.  Corrections to the terrestrial
//       pole can be computed using sla_POLMO.
//
//  Called:  sla_DCS2C, sla_REFZ, sla_REFRO, sla_DCC2S, sla_DRANRM
//
//  P.T.Wallace   Starlink   24 October 2003
//
//  Copyright (C) 2003 Rutherford Appleton Laboratory
//


struct aopqk 
{
double AOB;double ZOB;double HOB;double DOB;double ROB;

  aopqk( const double RAP,const double DAP,const double AOPRMS[14] )
  {
   sla_aopqk_( &RAP,&DAP,AOPRMS,&AOB,&ZOB,&HOB,&DOB,&ROB );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "AOB,ZOB,HOB,DOB,ROB : " << AOB<<" "<<ZOB<<" "<<HOB<<" "<<DOB<<" "<<ROB << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const aopqk& o ) { return s << o.__str__(); }

//     - - -
//      P M
//     - - -
//
//  Apply corrections for proper motion to a star RA,Dec
//  (double precision)
//
//  References:
//     1984 Astronomical Almanac, pp B39-B41.
//     (also Lederle & Schwan, Astron. Astrophys. 134,
//      1-6, 1984)
//
//  Given:
//     R0,D0    dp     RA,Dec at epoch EP0 (rad)
//     PR,PD    dp     proper motions:  RA,Dec changes per year of epoch
//     PX       dp     parallax (arcsec)
//     RV       dp     radial velocity (km/sec, +ve if receding)
//     EP0      dp     start epoch in years (e.g. Julian epoch)
//     EP1      dp     end epoch in years (same system as EP0)
//
//  Returned:
//     R1,D1    dp     RA,Dec at epoch EP1 (rad)
//
//  Called:
//     sla_DCS2C       spherical to Cartesian
//     sla_DCC2S       Cartesian to spherical
//     sla_DRANRM      normalize angle 0-2Pi
//
//  Notes:
//
//  1  The proper motions in RA are dRA/dt rather than cos(Dec)*dRA/dt,
//     and are in the same coordinate system as R0,D0.
//
//  2  If the available proper motions are pre-FK5 they will be per
//     tropical year rather than per Julian year, and so the epochs
//     must both be Besselian rather than Julian.  In such cases, a
//     scaling factor of 365.2422D0/365.25D0 should be applied to the
//     radial velocity before use.
//
//  P.T.Wallace   Starlink   19 January 2000
//
//  Copyright (C) 2000 Rutherford Appleton Laboratory
//


struct pm 
{
double R1;double D1;

  pm( const double R0,const double D0,const double PR,const double PD,const double PX,const double RV,const double EP0,const double EP1 )
  {
   sla_pm_( &R0,&D0,&PR,&PD,&PX,&RV,&EP0,&EP1,&R1,&D1 );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "R1,D1 : " << R1<<" "<<D1 << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const pm& o ) { return s << o.__str__(); }

//     - - - - -
//      S E P V
//     - - - - -
//
//  Angle between two vectors.
//
//  (single precision)
//
//  Given:
//     V1      r(3)    first vector
//     V2      r(3)    second vector
//
//  The result is the angle, in radians, between the two vectors.  It
//  is always positive.
//
//  Notes:
//
//  1  There is no requirement for the vectors to be unit length.
//
//  2  If either vector is null, zero is returned.
//
//  3  The simplest formulation would use dot product alone.  However,
//     this would reduce the accuracy for angles near zero and pi.  The
//     algorithm uses both cross product and dot product, which maintains
//     accuracy for all sizes of angle.
//
//  Called:  sla_DSEPV
//
//  Last revision:   7 May 2000
//
//  Copyright P.T.Wallace.  All rights reserved.
//


inline float sepv( const float V1[3],const float V2[3] )
{
 return sla_sepv_( V1,V2 );
};
//     - - - - - -
//      I N T I N
//     - - - - - -
//
//  Convert free-format input into an integer
//
//  Given:
//     STRING     c     string containing number to be decoded
//     NSTRT      i     pointer to where decoding is to start
//     IRESLT     i     current value of result
//
//  Returned:
//     NSTRT      i      advanced to next number
//     IRESLT     i      result
//     JFLAG      i      status: -1 = -OK, 0 = +OK, 1 = null, 2 = error
//
//  Called:  sla__IDCHI
//
//  Notes:
//
//     1     The reason INTIN has separate OK status values for +
//           and - is to enable minus zero to be detected.   This is
//           of crucial importance when decoding mixed-radix numbers.
//           For example, an angle expressed as deg, arcmin, arcsec
//           may have a leading minus sign but a zero degrees field.
//
//     2     A TAB is interpreted as a space.
//
//     3     The basic format is the sequence of fields #^, where
//           # is a sign character + or -, and ^ means a string of
//           decimal digits.
//
//     4     Spaces:
//
//             .  Leading spaces are ignored.
//
//             .  Spaces between the sign and the number are allowed.
//
//             .  Trailing spaces are ignored;  the first signifies
//                end of decoding and subsequent ones are skipped.
//
//     5     Delimiters:
//
//             .  Any character other than +,-,0-9 or space may be
//                used to signal the end of the number and terminate
//                decoding.
//
//             .  Comma is recognized by INTIN as a special case;  it
//                is skipped, leaving the pointer on the next character.
//                See 9, below.
//
//     6     The sign is optional.  The default is +.
//
//     7     A "null result" occurs when the string of characters being
//           decoded does not begin with +,- or 0-9, or consists
//           entirely of spaces.  When this condition is detected, JFLAG
//           is set to 1 and IRESLT is left untouched.
//
//     8     NSTRT = 1 for the first character in the string.
//
//     9     On return from INTIN, NSTRT is set ready for the next
//           decode - following trailing blanks and any comma.  If a
//           delimiter other than comma is being used, NSTRT must be
//           incremented before the next call to INTIN, otherwise
//           all subsequent calls will return a null result.
//
//     10    Errors (JFLAG=2) occur when:
//
//             .  there is a + or - but no number;  or
//
//             .  the number is greater than BIG (defined below).
//
//     11    When an error has been detected, NSTRT is left
//           pointing to the character following the last
//           one used before the error came to light.
//
//     12    See also FLOTIN and DFLTIN.
//
//  P.T.Wallace   Starlink   27 April 1998
//
//  Copyright (C) 1998 Rutherford Appleton Laboratory
//


struct intin 
{
int JFLAG;

  intin( const char STRING,int NSTRT,int IRESLT )
  {
   sla_intin_( &STRING,&NSTRT,&IRESLT,&JFLAG );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "JFLAG : " << JFLAG << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const intin& o ) { return s << o.__str__(); }

//     - - - - - -
//      C R 2 T F
//     - - - - - -
//
//  Convert an angle in radians into hours, minutes, seconds
//  (single precision)
//
//  Given:
//     NDP       int      number of decimal places of seconds
//     ANGLE     real     angle in radians
//
//  Returned:
//     SIGN      char     '+' or '-'
//     IHMSF     int(4)   hours, minutes, seconds, fraction
//
//  Notes:
//
//  1)  NDP less than zero is interpreted as zero.
//
//  2)  The largest useful value for NDP is determined by the size of
//      ANGLE, the format of REAL floating-point numbers on the target
//      machine, and the risk of overflowing IHMSF(4).  On some
//      architectures, for ANGLE up to 2pi, the available floating-point
//      precision corresponds roughly to NDP=3.  This is well below
//      the ultimate limit of NDP=9 set by the capacity of a typical
//      32-bit IHMSF(4).
//
//  3)  The absolute value of ANGLE may exceed 2pi.  In cases where it
//      does not, it is up to the caller to test for and handle the
//      case where ANGLE is very nearly 2pi and rounds up to 24 hours,
//      by testing for IHMSF(1)=24 and setting IHMSF(1-4) to zero.
//
//  Called:  sla_CD2TF
//
//  Last revision:   26 December 2004
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct cr2tf 
{
char SIGN;int IHMSF[4];

  cr2tf( const int NDP,const float ANGLE )
  {
   sla_cr2tf_( &NDP,&ANGLE,&SIGN,IHMSF );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "SIGN,IHMSF : " << SIGN<<" "<<IHMSF << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const cr2tf& o ) { return s << o.__str__(); }

//     - - - - - - -
//      P L A N E T
//     - - - - - - -
//
//  Approximate heliocentric position and velocity of a specified
//  major planet.
//
//  Given:
//     DATE      d      Modified Julian Date (JD - 2400000.5)
//     NP        i      planet (1=Mercury, 2=Venus, 3=EMB ... 9=Pluto)
//
//  Returned:
//     PV        d(6)   heliocentric x,y,z,xdot,ydot,zdot, J2000
//                                           equatorial triad (AU,AU/s)
//     JSTAT     i      status: +1 = warning: date out of range
//                               0 = OK
//                              -1 = illegal NP (outside 1-9)
//                              -2 = solution didn't converge
//
//  Called:  sla_PLANEL
//
//  Notes
//
//  1  The epoch, DATE, is in the TDB timescale and is a Modified
//     Julian Date (JD-2400000.5).
//
//  2  The reference frame is equatorial and is with respect to the
//     mean equinox and ecliptic of epoch J2000.
//
//  3  If an NP value outside the range 1-9 is supplied, an error
//     status (JSTAT = -1) is returned and the PV vector set to zeroes.
//
//  4  The algorithm for obtaining the mean elements of the planets
//     from Mercury to Neptune is due to J.L. Simon, P. Bretagnon,
//     J. Chapront, M. Chapront-Touze, G. Francou and J. Laskar
//     (Bureau des Longitudes, Paris).  The (completely different)
//     algorithm for calculating the ecliptic coordinates of Pluto
//     is by Meeus.
//
//  5  Comparisons of the present routine with the JPL DE200 ephemeris
//     give the following RMS errors over the interval 1960-2025:
//
//                      position (km)     speed (metre/sec)
//
//        Mercury            334               0.437
//        Venus             1060               0.855
//        EMB               2010               0.815
//        Mars              7690               1.98
//        Jupiter          71700               7.70
//        Saturn          199000              19.4
//        Uranus          564000              16.4
//        Neptune         158000              14.4
//        Pluto            36400               0.137
//
//     From comparisons with DE102, Simon et al quote the following
//     longitude accuracies over the interval 1800-2200:
//
//        Mercury                 4"
//        Venus                   5"
//        EMB                     6"
//        Mars                   17"
//        Jupiter                71"
//        Saturn                 81"
//        Uranus                 86"
//        Neptune                11"
//
//     In the case of Pluto, Meeus quotes an accuracy of 0.6 arcsec
//     in longitude and 0.2 arcsec in latitude for the period
//     1885-2099.
//
//     For all except Pluto, over the period 1000-3000 the accuracy
//     is better than 1.5 times that over 1800-2200.  Outside the
//     period 1000-3000 the accuracy declines.  For Pluto the
//     accuracy declines rapidly outside the period 1885-2099.
//     Outside these ranges (1885-2099 for Pluto, 1000-3000 for
//     the rest) a "date out of range" warning status (JSTAT=+1)
//     is returned.
//
//  6  The algorithms for (i) Mercury through Neptune and (ii) Pluto
//     are completely independent.  In the Mercury through Neptune
//     case, the present SLALIB implementation differs from the
//     original Simon et al Fortran code in the following respects.
//
//     *  The date is supplied as a Modified Julian Date rather
//        than a Julian Date (MJD = JD - 2400000.5).
//
//     *  The result is returned only in equatorial Cartesian form;
//        the ecliptic longitude, latitude and radius vector are not
//        returned.
//
//     *  The velocity is in AU per second, not AU per day.
//
//     *  Different error/warning status values are used.
//
//     *  Kepler's equation is not solved inline.
//
//     *  Polynomials in T are nested to minimize rounding errors.
//
//     *  Explicit double-precision constants are used to avoid
//        mixed-mode expressions.
//
//     *  There are other, cosmetic, changes to comply with
//        Starlink/SLALIB style guidelines.
//
//     None of the above changes affects the result significantly.
//
//  7  For NP=3 the result is for the Earth-Moon Barycentre.  To
//     obtain the heliocentric position and velocity of the Earth,
//     either use the SLALIB routine sla_EVP (or sla_EPV) or call
//     sla_DMOON and subtract 0.012150581 times the geocentric Moon
//     vector from the EMB vector produced by the present routine.
//     (The Moon vector should be precessed to J2000 first, but this
//     can be omitted for modern epochs without introducing significant
//     inaccuracy.)
//
//  References:  Simon et al., Astron. Astrophys. 282, 663 (1994).
//               Meeus, Astronomical Algorithms, Willmann-Bell (1991).
//
//  This revision:  19 June 2004
//
//  Copyright (C) 2004 P.T.Wallace.  All rights reserved.
//


struct planet 
{
double PV[6];int JSTAT;

  planet( const double DATE,const int NP )
  {
   sla_planet_( &DATE,&NP,PV,&JSTAT );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "PV,JSTAT : " << PV<<" "<<JSTAT << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const planet& o ) { return s << o.__str__(); }

//     - - - -
//      V X V
//     - - - -
//
//  Vector product of two 3-vectors (single precision)
//
//  Given:
//      VA      real(3)     first vector
//      VB      real(3)     second vector
//
//  Returned:
//      VC      real(3)     vector result
//
//  P.T.Wallace   Starlink   March 1986
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct vxv 
{
float VC[3];

  vxv( const float VA[3],const float VB[3] )
  {
   sla_vxv_( VA,VB,VC );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "VC : " << VC << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const vxv& o ) { return s << o.__str__(); }

//     - - -
//      Z D
//     - - -
//
//  HA, Dec to Zenith Distance (double precision)
//
//  Given:
//     HA     d     Hour Angle in radians
//     DEC    d     declination in radians
//     PHI    d     observatory latitude in radians
//
//  The result is in the range 0 to pi.
//
//  Notes:
//
//  1)  The latitude must be geodetic.  In critical applications,
//      corrections for polar motion should be applied.
//
//  2)  In some applications it will be important to specify the
//      correct type of hour angle and declination in order to
//      produce the required type of zenith distance.  In particular,
//      it may be important to distinguish between the zenith distance
//      as affected by refraction, which would require the "observed"
//      HA,Dec, and the zenith distance in vacuo, which would require
//      the "topocentric" HA,Dec.  If the effects of diurnal aberration
//      can be neglected, the "apparent" HA,Dec may be used instead of
//      the topocentric HA,Dec.
//
//  3)  No range checking of arguments is done.
//
//  4)  In applications which involve many zenith distance calculations,
//      rather than calling the present routine it will be more efficient
//      to use inline code, having previously computed fixed terms such
//      as sine and cosine of latitude, and perhaps sine and cosine of
//      declination.
//
//  P.T.Wallace   Starlink   3 April 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


inline double zd( const double HA,const double DEC,const double PHI )
{
 return sla_zd_( &HA,&DEC,&PHI );
};
//     - - - -
//      P C D
//     - - - -
//
//  Apply pincushion/barrel distortion to a tangent-plane [x,y].
//
//  Given:
//     DISCO    d      pincushion/barrel distortion coefficient
//     X,Y      d      tangent-plane coordinates
//
//  Returned:
//     X,Y      d      distorted coordinates
//
//  Notes:
//
//  1)  The distortion is of the form RP = R*(1 + C*R**2), where R is
//      the radial distance from the tangent point, C is the DISCO
//      argument, and RP is the radial distance in the presence of
//      the distortion.
//
//  2)  For pincushion distortion, C is +ve;  for barrel distortion,
//      C is -ve.
//
//  3)  For X,Y in units of one projection radius (in the case of
//      a photographic plate, the focal length), the following
//      DISCO values apply:
//
//          Geometry          DISCO
//
//          astrograph         0.0
//          Schmidt           -0.3333
//          AAT PF doublet  +147.069
//          AAT PF triplet  +178.585
//          AAT f/8          +21.20
//          JKT f/8          +13.32
//
//  4)  There is a companion routine, sla_UNPCD, which performs the
//      inverse operation.
//
//  P.T.Wallace   Starlink   3 September 2000
//
//  Copyright (C) 2000 Rutherford Appleton Laboratory
//


struct pcd 
{
;

  pcd( const double DISCO,double X,double Y )
  {
   sla_pcd_( &DISCO,&X,&Y );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << " : " << "<obj holds not state>" << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const pcd& o ) { return s << o.__str__(); }

//     - - - - -
//      E C O R
//     - - - - -
//
//  Component of Earth orbit velocity and heliocentric
//  light time in a given direction (single precision)
//
//  Given:
//     RM,DM    real    mean RA, Dec of date (radians)
//     IY       int     year
//     ID       int     day in year (1 = Jan 1st)
//     FD       real    fraction of day
//
//  Returned:
//     RV       real    component of Earth orbital velocity (km/sec)
//     TL       real    component of heliocentric light time (sec)
//
//  Notes:
//
//  1  The date and time is TDB (loosely ET) in a Julian calendar
//     which has been aligned to the ordinary Gregorian
//     calendar for the interval 1900 March 1 to 2100 February 28.
//     The year and day can be obtained by calling sla_CALYD or
//     sla_CLYD.
//
//  2  Sign convention:
//
//     The velocity component is +ve when the Earth is receding from
//     the given point on the sky.  The light time component is +ve
//     when the Earth lies between the Sun and the given point on
//     the sky.
//
//  3  Accuracy:
//
//     The velocity component is usually within 0.004 km/s of the
//     correct value and is never in error by more than 0.007 km/s.
//     The error in light time correction is about 0.03s at worst,
//     but is usually better than 0.01s. For applications requiring
//     higher accuracy, see the sla_EVP and sla_EPV routines.
//
//  Called:  sla_EARTH, sla_CS2C, sla_VDV
//
//  Last revision:   5 April 2005
//
//  Copyright P.T.Wallace.  All rights reserved.
//


struct ecor 
{
float RV;float TL;

  ecor( const float RM,const float DM,const int IY,const int ID,const float FD )
  {
   sla_ecor_( &RM,&DM,&IY,&ID,&FD,&RV,&TL );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "RV,TL : " << RV<<" "<<TL << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const ecor& o ) { return s << o.__str__(); }

//     - - - - - - -
//      F L O T I N
//     - - - - - - -
//
//  Convert free-format input into single precision floating point
//
//  Given:
//     STRING     c     string containing number to be decoded
//     NSTRT      i     pointer to where decoding is to start
//     RESLT      r     current value of result
//
//  Returned:
//     NSTRT      i      advanced to next number
//     RESLT      r      result
//     JFLAG      i      status: -1 = -OK, 0 = +OK, 1 = null, 2 = error
//
//  Called:  sla_DFLTIN
//
//  Notes:
//
//     1     The reason FLOTIN has separate OK status values for +
//           and - is to enable minus zero to be detected.   This is
//           of crucial importance when decoding mixed-radix numbers.
//           For example, an angle expressed as deg, arcmin, arcsec
//           may have a leading minus sign but a zero degrees field.
//
//     2     A TAB is interpreted as a space, and lowercase characters
//           are interpreted as uppercase.
//
//     3     The basic format is the sequence of fields #^.^@#^, where
//           # is a sign character + or -, ^ means a string of decimal
//           digits, and @, which indicates an exponent, means D or E.
//           Various combinations of these fields can be omitted, and
//           embedded blanks are permissible in certain places.
//
//     4     Spaces:
//
//             .  Leading spaces are ignored.
//
//             .  Embedded spaces are allowed only after +, -, D or E,
//                and after the decomal point if the first sequence of
//                digits is absent.
//
//             .  Trailing spaces are ignored;  the first signifies
//                end of decoding and subsequent ones are skipped.
//
//     5     Delimiters:
//
//             .  Any character other than +,-,0-9,.,D,E or space may be
//                used to signal the end of the number and terminate
//                decoding.
//
//             .  Comma is recognized by FLOTIN as a special case;  it
//                is skipped, leaving the pointer on the next character.
//                See 13, below.
//
//     6     Both signs are optional.  The default is +.
//
//     7     The mantissa ^.^ defaults to 1.
//
//     8     The exponent @#^ defaults to E0.
//
//     9     The strings of decimal digits may be of any length.
//
//     10    The decimal point is optional for whole numbers.
//
//     11    A "null result" occurs when the string of characters being
//           decoded does not begin with +,-,0-9,.,D or E, or consists
//           entirely of spaces.  When this condition is detected, JFLAG
//           is set to 1 and RESLT is left untouched.
//
//     12    NSTRT = 1 for the first character in the string.
//
//     13    On return from FLOTIN, NSTRT is set ready for the next
//           decode - following trailing blanks and any comma.  If a
//           delimiter other than comma is being used, NSTRT must be
//           incremented before the next call to FLOTIN, otherwise
//           all subsequent calls will return a null result.
//
//     14    Errors (JFLAG=2) occur when:
//
//             .  a +, -, D or E is left unsatisfied;  or
//
//             .  the decimal point is present without at least
//                one decimal digit before or after it;  or
//
//             .  an exponent more than 100 has been presented.
//
//     15    When an error has been detected, NSTRT is left
//           pointing to the character following the last
//           one used before the error came to light.  This
//           may be after the point at which a more sophisticated
//           program could have detected the error.  For example,
//           FLOTIN does not detect that '1E999' is unacceptable
//           (on a computer where this is so) until the entire number
//           has been decoded.
//
//     16    Certain highly unlikely combinations of mantissa &
//           exponent can cause arithmetic faults during the
//           decode, in some cases despite the fact that they
//           together could be construed as a valid number.
//
//     17    Decoding is left to right, one pass.
//
//     18    See also DFLTIN and INTIN
//
//  P.T.Wallace   Starlink   23 November 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct flotin 
{
int JFLAG;

  flotin( const char STRING,int NSTRT,float RESLT )
  {
   sla_flotin_( &STRING,&NSTRT,&RESLT,&JFLAG );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "JFLAG : " << JFLAG << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const flotin& o ) { return s << o.__str__(); }

//     - - - - - -
//      D T P 2 V
//     - - - - - -
//
//  Given the tangent-plane coordinates of a star and the direction
//  cosines of the tangent point, determine the direction cosines
//  of the star.
//
//  (double precision)
//
//  Given:
//     XI,ETA    d       tangent plane coordinates of star
//     V0        d(3)    direction cosines of tangent point
//
//  Returned:
//     V         d(3)    direction cosines of star
//
//  Notes:
//
//  1  If vector V0 is not of unit length, the returned vector V will
//     be wrong.
//
//  2  If vector V0 points at a pole, the returned vector V will be
//     based on the arbitrary assumption that the RA of the tangent
//     point is zero.
//
//  3  This routine is the Cartesian equivalent of the routine sla_DTP2S.
//
//  P.T.Wallace   Starlink   11 February 1995
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct dtp2v 
{
double V[3];

  dtp2v( const double XI,const double ETA,const double V0[3] )
  {
   sla_dtp2v_( &XI,&ETA,V0,V );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "V : " << V << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const dtp2v& o ) { return s << o.__str__(); }

//     - - - -
//      E 2 H
//     - - - -
//
//  Equatorial to horizon coordinates:  HA,Dec to Az,El
//
//  (single precision)
//
//  Given:
//     HA      r     hour angle
//     DEC     r     declination
//     PHI     r     observatory latitude
//
//  Returned:
//     AZ      r     azimuth
//     EL      r     elevation
//
//  Notes:
//
//  1)  All the arguments are angles in radians.
//
//  2)  Azimuth is returned in the range 0-2pi;  north is zero,
//      and east is +pi/2.  Elevation is returned in the range
//      +/-pi/2.
//
//  3)  The latitude must be geodetic.  In critical applications,
//      corrections for polar motion should be applied.
//
//  4)  In some applications it will be important to specify the
//      correct type of hour angle and declination in order to
//      produce the required type of azimuth and elevation.  In
//      particular, it may be important to distinguish between
//      elevation as affected by refraction, which would
//      require the "observed" HA,Dec, and the elevation
//      in vacuo, which would require the "topocentric" HA,Dec.
//      If the effects of diurnal aberration can be neglected, the
//      "apparent" HA,Dec may be used instead of the topocentric
//      HA,Dec.
//
//  5)  No range checking of arguments is carried out.
//
//  6)  In applications which involve many such calculations, rather
//      than calling the present routine it will be more efficient to
//      use inline code, having previously computed fixed terms such
//      as sine and cosine of latitude, and (for tracking a star)
//      sine and cosine of declination.
//
//  P.T.Wallace   Starlink   9 July 1994
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct e2h 
{
float AZ;float EL;

  e2h( const float HA,const float DEC,const float PHI )
  {
   sla_e2h_( &HA,&DEC,&PHI,&AZ,&EL );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "AZ,EL : " << AZ<<" "<<EL << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const e2h& o ) { return s << o.__str__(); }

//     - - - - - -
//      F K 5 2 4
//     - - - - - -
//
//  Convert J2000.0 FK5 star data to B1950.0 FK4 (double precision)
//
//  This routine converts stars from the new, IAU 1976, FK5, Fricke
//  system, to the old, Bessel-Newcomb, FK4 system.  The precepts
//  of Smith et al (Ref 1) are followed, using the implementation
//  by Yallop et al (Ref 2) of a matrix method due to Standish.
//  Kinoshita's development of Andoyer's post-Newcomb precession is
//  used.  The numerical constants from Seidelmann et al (Ref 3) are
//  used canonically.
//
//  Given:  (all J2000.0,FK5)
//     R2000,D2000     dp    J2000.0 RA,Dec (rad)
//     DR2000,DD2000   dp    J2000.0 proper motions (rad/Jul.yr)
//     P2000           dp    parallax (arcsec)
//     V2000           dp    radial velocity (km/s, +ve = moving away)
//
//  Returned:  (all B1950.0,FK4)
//     R1950,D1950     dp    B1950.0 RA,Dec (rad)
//     DR1950,DD1950   dp    B1950.0 proper motions (rad/trop.yr)
//     P1950           dp    parallax (arcsec)
//     V1950           dp    radial velocity (km/s, +ve = moving away)
//
//  Notes:
//
//  1)  The proper motions in RA are dRA/dt rather than
//      cos(Dec)*dRA/dt, and are per year rather than per century.
//
//  2)  Note that conversion from Julian epoch 2000.0 to Besselian
//      epoch 1950.0 only is provided for.  Conversions involving
//      other epochs will require use of the appropriate precession,
//      proper motion, and E-terms routines before and/or after
//      FK524 is called.
//
//  3)  In the FK4 catalogue the proper motions of stars within
//      10 degrees of the poles do not embody the differential
//      E-term effect and should, strictly speaking, be handled
//      in a different manner from stars outside these regions.
//      However, given the general lack of homogeneity of the star
//      data available for routine astrometry, the difficulties of
//      handling positions that may have been determined from
//      astrometric fields spanning the polar and non-polar regions,
//      the likelihood that the differential E-terms effect was not
//      taken into account when allowing for proper motion in past
//      astrometry, and the undesirability of a discontinuity in
//      the algorithm, the decision has been made in this routine to
//      include the effect of differential E-terms on the proper
//      motions for all stars, whether polar or not.  At epoch 2000,
//      and measuring on the sky rather than in terms of dRA, the
//      errors resulting from this simplification are less than
//      1 milliarcsecond in position and 1 milliarcsecond per
//      century in proper motion.
//
//  References:
//
//     1  Smith, C.A. et al, 1989.  "The transformation of astrometric
//        catalog systems to the equinox J2000.0".  Astron.J. 97, 265.
//
//     2  Yallop, B.D. et al, 1989.  "Transformation of mean star places
//        from FK4 B1950.0 to FK5 J2000.0 using matrices in 6-space".
//        Astron.J. 97, 274.
//
//     3  Seidelmann, P.K. (ed), 1992.  "Explanatory Supplement to
//        the Astronomical Almanac", ISBN 0-935702-68-7.
//
//  P.T.Wallace   Starlink   19 December 1993
//
//  Copyright (C) 1995 Rutherford Appleton Laboratory
//


struct fk524 
{
double R1950;double D1950;double DR1950;double DD1950;double P1950;double V1950;

  fk524( const double R2000,const double D2000,const double DR2000,const double DD2000,const double P2000,const double V2000 )
  {
   sla_fk524_( &R2000,&D2000,&DR2000,&DD2000,&P2000,&V2000,&R1950,&D1950,&DR1950,&DD1950,&P1950,&V1950 );
  } 

 std::string __str__() const 
 { 
   std::ostringstream s; 
   s << "R1950,D1950,DR1950,DD1950,P1950,V1950 : " << R1950<<" "<<D1950<<" "<<DR1950<<" "<<DD1950<<" "<<P1950<<" "<<V1950 << endl;
   return s.str(); 
 }

};

inline ostream& operator<<(ostream& s, const fk524& o ) { return s << o.__str__(); }

 


}
#endif