Constants.hpp

Go to the documentation of this file.

 
#if !defined(GEOGRAPHICLIB_CONSTANTS_HPP)
#define GEOGRAPHICLIB_CONSTANTS_HPP 1
 
#include <GeographicLib/Config.h>
 
#define GEOGRAPHICLIB_VERSION_NUM(a,b,c) ((((a) * 10000 + (b)) * 100) + (c))
 
#define GEOGRAPHICLIB_VERSION \
 GEOGRAPHICLIB_VERSION_NUM(GEOGRAPHICLIB_VERSION_MAJOR, \
                           GEOGRAPHICLIB_VERSION_MINOR, \
                           GEOGRAPHICLIB_VERSION_PATCH)
 
#if !defined(GEOGRAPHICLIB_HAS_STATIC_ASSERT)
#  if __cplusplus >= 201103 || defined(__GXX_EXPERIMENTAL_CXX0X__)
#    define GEOGRAPHICLIB_HAS_STATIC_ASSERT 1
#  elif defined(_MSC_VER) && _MSC_VER >= 1600
// For reference, here is a table of Visual Studio and _MSC_VER
// correspondences:
//
// _MSC_VER  Visual Studio
//   1100     vc5
//   1200     vc6
//   1300     vc7
//   1310     vc7.1 (2003)
//   1400     vc8   (2005)
//   1500     vc9   (2008)
//   1600     vc10  (2010)
//   1700     vc11  (2012)
//   1800     vc12  (2013)
//   1900     vc14  (2015)
//   1910+    vc15  (2017)
#    define GEOGRAPHICLIB_HAS_STATIC_ASSERT 1
#  else
#    define GEOGRAPHICLIB_HAS_STATIC_ASSERT 0
#  endif
#endif
 
#if !defined(GEOGRAPHICLIB_STATIC_ASSERT)
#  if GEOGRAPHICLIB_HAS_STATIC_ASSERT
#    define GEOGRAPHICLIB_STATIC_ASSERT static_assert
#  else
#    define GEOGRAPHICLIB_STATIC_ASSERT(cond,reason) \
            { enum{ GEOGRAPHICLIB_STATIC_ASSERT_ENUM = 1/int(cond) }; }
#  endif
#endif
 
#if defined(_MSC_VER) && defined(GEOGRAPHICLIB_SHARED_LIB) && \
  GEOGRAPHICLIB_SHARED_LIB
#  if GEOGRAPHICLIB_SHARED_LIB > 1
#    error GEOGRAPHICLIB_SHARED_LIB must be 0 or 1
#  elif defined(GeographicLib_EXPORTS)
#    define GEOGRAPHICLIB_EXPORT __declspec(dllexport)
#  else
#    define GEOGRAPHICLIB_EXPORT __declspec(dllimport)
#  endif
#else
#  define GEOGRAPHICLIB_EXPORT
#endif
 
// Use GEOGRAPHICLIB_DEPRECATED to mark functions, types or variables as
// deprecated.  Code inspired by Apache Subversion's svn_types.h file (via
// MPFR).
#if defined(__GNUC__)
#  if __GNUC__ > 4
#    define GEOGRAPHICLIB_DEPRECATED(msg) __attribute__((deprecated(msg)))
#  else
#    define GEOGRAPHICLIB_DEPRECATED(msg) __attribute__((deprecated))
#  endif
#elif defined(_MSC_VER) && _MSC_VER >= 1300
#  define GEOGRAPHICLIB_DEPRECATED(msg) __declspec(deprecated(msg))
#else
#  define GEOGRAPHICLIB_DEPRECATED(msg)
#endif
 
#include <stdexcept>
#include <string>
#include <GeographicLib/Math.hpp>
 
namespace GeographicLib {
 
  class GEOGRAPHICLIB_EXPORT Constants {
  private:
    typedef Math::real real;
    Constants();                // Disable constructor
 
  public:
    static Math::real degree() { return Math::degree(); }
    static Math::real arcminute()
    { return Math::degree() / 60; }
    static Math::real arcsecond()
    { return Math::degree() / 3600; }
 
 
    template<typename T> static T WGS84_a()
    { return 6378137 * meter<T>(); }
    static Math::real WGS84_a() { return WGS84_a<real>(); }
    template<typename T> static T WGS84_f() {
      // Evaluating this as 1000000000 / T(298257223563LL) reduces the
      // round-off error by about 10%.  However, expressing the flattening as
      // 1/298.257223563 is well ingrained.
      return 1 / ( T(298257223563LL) / 1000000000 );
    }
    static Math::real WGS84_f() { return WGS84_f<real>(); }
    template<typename T> static T WGS84_GM()
    { return T(3986004) * 100000000 + 41800000; }
    static Math::real WGS84_GM() { return WGS84_GM<real>(); }
    template<typename T> static T WGS84_omega()
    { return 7292115 / (T(1000000) * 100000); }
    static Math::real WGS84_omega() { return WGS84_omega<real>(); }
    template<typename T> static T GRS80_a()
    { return 6378137 * meter<T>(); }
    static Math::real GRS80_a() { return GRS80_a<real>(); }
    template<typename T> static T GRS80_GM()
    { return T(3986005) * 100000000; }
    static Math::real GRS80_GM() { return GRS80_GM<real>(); }
    template<typename T> static T GRS80_omega()
    { return 7292115 / (T(1000000) * 100000); }
    static Math::real GRS80_omega() { return GRS80_omega<real>(); }
    template<typename T> static T GRS80_J2()
    { return T(108263) / 100000000; }
    static Math::real GRS80_J2() { return GRS80_J2<real>(); }
    template<typename T> static T UTM_k0()
    {return T(9996) / 10000; }
    static Math::real UTM_k0() { return UTM_k0<real>(); }
    template<typename T> static T UPS_k0()
    { return T(994) / 1000; }
    static Math::real UPS_k0() { return UPS_k0<real>(); }
 
 
    template<typename T> static T meter() { return T(1); }
    static Math::real meter() { return meter<real>(); }
    static Math::real kilometer()
    { return 1000 * meter<real>(); }
    static Math::real nauticalmile()
    { return 1852 * meter<real>(); }
 
    template<typename T> static T square_meter()
    { return meter<real>() * meter<real>(); }
    static Math::real square_meter()
    { return square_meter<real>(); }
    static Math::real hectare()
    { return 10000 * square_meter<real>(); }
    static Math::real square_kilometer()
    { return kilometer() * kilometer(); }
    static Math::real square_nauticalmile()
    { return nauticalmile() * nauticalmile(); }
 
 
    static Math::real foot()
    { return real(254 * 12) / 10000 * meter<real>(); }
    static Math::real yard() { return 3 * foot(); }
    static Math::real fathom() { return 2 * yard(); }
    static Math::real chain() { return 22 * yard(); }
    static Math::real furlong() { return 10 * chain(); }
    static Math::real mile() { return 8 * furlong(); }
    static Math::real acre() { return chain() * furlong(); }
    static Math::real square_mile() { return mile() * mile(); }
 
 
    static Math::real surveyfoot()
    { return real(1200) / 3937 * meter<real>(); }
  };
 
  class GeographicErr : public std::runtime_error {
  public:
 
    GeographicErr(const std::string& msg) : std::runtime_error(msg) {}
  };
 
} // namespace GeographicLib
 
#endif  // GEOGRAPHICLIB_CONSTANTS_HPP