MJD.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 1998 by Matthew Britton
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Util/genutil/MJD.h
 
#ifndef __GENUTIL_MJD_H
#define __GENUTIL_MJD_H
 
#include <inttypes.h>
#include "utc.h"
 
#include <iostream>
#include <limits>
#include <string>
#include <stdio.h>

class MJD {
 
 private:
  int    days;
  int    secs;
  double fracsec;
 
  void add_day (double dd);
  void settle();
 
 public:
  static const MJD zero;
 
  static double   precision;
  static unsigned ostream_precision;
 
  static int verbose;

  MJD () { days=0;secs=0;fracsec=0.0; };

  MJD (double dd);                        // mjd given as day
  MJD (int intday, double fracday);       // mjd given with separate fracday
  MJD (double dd, double ss, double fs);  // mjd with seconds and fracsec
  MJD (int dd, int ss, double fs);        // again

  MJD (const char* mjdstring);

  MJD (time_t time);                // returned by time()
  MJD (const struct tm& greg);      // returned by gmtime()
  MJD (const struct timeval& tp);   // returned by gettimeofday()

  MJD (const utc_t& utc);

  MJD (const std::string& mjd);

  int Construct (const char* mjdstr);

  int Construct (time_t time);

  int Construct (const struct tm& greg);

  int Construct (const struct timeval& tp);

  int Construct (const utc_t& utc);


  int Construct (uint64_t bat);
 
  double in_seconds() const;
  double in_days()    const;
  double in_minutes() const;
 
  // cast into other forms
  int UTC       (utc_t* utc, double* fsec=NULL) const;
  int gregorian (struct tm* gregdate, double* fsec=NULL) const;
 
  MJD & operator = (const MJD &);
  MJD & operator += (const MJD &);
  MJD & operator -= (const MJD &);
  MJD & operator += (const double &);
  MJD & operator -= (const double &);
  MJD & operator *= (const double &);
  MJD & operator /= (const double &);
  friend const MJD operator + (const MJD &, const MJD &);
  friend const MJD operator - (const MJD &, const MJD &);
  friend const MJD operator + (const MJD &, double);  // Add seconds to an MJD
  friend const MJD operator - (const MJD &, double);  // Take seconds from MJD
  friend const MJD operator * (const MJD &, double);  
  friend const MJD operator * (double a, const MJD& m) { return m * a; }
  friend const MJD operator / (const MJD &, double);  
 
  // return the -ve of m
  friend const MJD operator - (MJD m);
 
  friend int operator > (const MJD &, const MJD &);
  friend int operator < (const MJD &, const MJD &);
  friend int operator >= (const MJD &, const MJD &);
  friend int operator <= (const MJD &, const MJD &);
  friend int operator == (const MJD &, const MJD &);
  friend int operator != (const MJD &, const MJD &);

  float plotval() const { return float (in_days()); };
  
  // These bits are useful for tempo
  int    intday()  const;                // To access the integer day
  double fracday() const;                // To access fractional day
  int    get_secs() const {return(secs);};
  double get_fracsec() const {return(fracsec);};


  double LST (double longitude) const;

  double GMST () const;
  
  std::string printdays (unsigned precision) const;
 
  int print (FILE *stream);
  int println (FILE *stream);
  std::string printall()    const;
  std::string printdays()   const;
  std::string printhhmmss() const;
  std::string printfs()     const;
  std::string strtempo() const; 


  char* datestr (char* dstr, int len, const char* format) const;

  std::string datestr (const char* format, unsigned fractional_second_digits = 0) const;

  void from_datestr (const std::string& datestr, const std::string& format = "%Y-%m-%d-%H:%M:%S");
 
 protected:
  friend bool equal (const MJD &m1, const MJD &m2);
 
};
 
inline double cast_double(const MJD&m) {return m.in_days();}
 
std::ostream& operator<< (std::ostream& ostr, const MJD& mjd);
std::istream& operator>> (std::istream& istr, MJD& mjd);
 
// Enable use of the MJD class with std C++ numeric_limits traits
namespace std {
  template<>
  class numeric_limits<MJD> {
    public:
    static const int digits10 = 15;
  };
}
 
#endif  /* not __MJD_H defined */