geographiclib 0.0.1

data/ext/geographiclib/GeographicLib/Config.h

@@ -0,0 +1,12 @@
+// This will be overwritten by ./configure
+
+#define GEOGRAPHICLIB_VERSION_STRING "1.46"
+#define GEOGRAPHICLIB_VERSION_MAJOR 1
+#define GEOGRAPHICLIB_VERSION_MINOR 46
+#define GEOGRAPHICLIB_VERSION_PATCH 0
+
+// Undefine HAVE_LONG_DOUBLE if this type is unknown to the compiler
+#define GEOGRAPHICLIB_HAVE_LONG_DOUBLE 1
+
+// Define WORDS_BIGENDIAN to be 1 if your machine is big endian
+/* #undef WORDS_BIGENDIAN */

data/ext/geographiclib/GeographicLib/Constants.hpp

@@ -0,0 +1,387 @@
+/**
+ * \file Constants.hpp
+ * \brief Header for GeographicLib::Constants class
+ *
+ * Copyright (c) Charles Karney (2008-2015) <charles@karney.com> and licensed
+ * under the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#if !defined(GEOGRAPHICLIB_CONSTANTS_HPP)
+#define GEOGRAPHICLIB_CONSTANTS_HPP 1
+
+#include <GeographicLib/Config.h>
+
+/**
+ * @relates GeographicLib::Constants
+ * Pack the version components into a single integer.  Users should not rely on
+ * this particular packing of the components of the version number; see the
+ * documentation for GEOGRAPHICLIB_VERSION, below.
+ **********************************************************************/
+#define GEOGRAPHICLIB_VERSION_NUM(a,b,c) ((((a) * 10000 + (b)) * 100) + (c))
+
+/**
+ * @relates GeographicLib::Constants
+ * The version of GeographicLib as a single integer, packed as MMmmmmpp where
+ * MM is the major version, mmmm is the minor version, and pp is the patch
+ * level.  Users should not rely on this particular packing of the components
+ * of the version number.  Instead they should use a test such as \code
+   #if GEOGRAPHICLIB_VERSION >= GEOGRAPHICLIB_VERSION_NUM(1,37,0)
+   ...
+   #endif
+ * \endcode
+ **********************************************************************/
+#define GEOGRAPHICLIB_VERSION \
+ GEOGRAPHICLIB_VERSION_NUM(GEOGRAPHICLIB_VERSION_MAJOR, \
+                           GEOGRAPHICLIB_VERSION_MINOR, \
+                           GEOGRAPHICLIB_VERSION_PATCH)
+
+/**
+ * @relates GeographicLib::Constants
+ * Is the C++11 static_assert available?
+ **********************************************************************/
+#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)
+#    define GEOGRAPHICLIB_HAS_STATIC_ASSERT 1
+#  else
+#    define GEOGRAPHICLIB_HAS_STATIC_ASSERT 0
+#  endif
+#endif
+
+/**
+ * @relates GeographicLib::Constants
+ * A compile-time assert.  Use C++11 static_assert, if available.
+ **********************************************************************/
+#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
+
+#include <stdexcept>
+#include <string>
+#include <GeographicLib/Math.hpp>
+
+/**
+ * \brief Namespace for %GeographicLib
+ *
+ * All of %GeographicLib is defined within the GeographicLib namespace.  In
+ * addition all the header files are included via %GeographicLib/Class.hpp.
+ * This minimizes the likelihood of conflicts with other packages.
+ **********************************************************************/
+namespace GeographicLib {
+
+  /**
+   * \brief %Constants needed by %GeographicLib
+   *
+   * Define constants specifying the WGS84 ellipsoid, the UTM and UPS
+   * projections, and various unit conversions.
+   *
+   * Example of use:
+   * \include example-Constants.cpp
+   **********************************************************************/
+  class GEOGRAPHICLIB_EXPORT Constants {
+  private:
+    typedef Math::real real;
+    Constants();                // Disable constructor
+
+  public:
+    /**
+     * A synonym for Math::degree<real>().
+     **********************************************************************/
+    static inline Math::real degree() { return Math::degree(); }
+    /**
+     * @return the number of radians in an arcminute.
+     **********************************************************************/
+    static inline Math::real arcminute()
+    { return Math::degree() / 60; }
+    /**
+     * @return the number of radians in an arcsecond.
+     **********************************************************************/
+    static inline Math::real arcsecond()
+    { return Math::degree() / 3600; }
+
+    /** \name Ellipsoid parameters
+     **********************************************************************/
+    ///@{
+    /**
+     * @tparam T the type of the returned value.
+     * @return the equatorial radius of WGS84 ellipsoid (6378137 m).
+     **********************************************************************/
+    template<typename T> static inline T WGS84_a()
+    { return 6378137 * meter<T>(); }
+    /**
+     * A synonym for WGS84_a<real>().
+     **********************************************************************/
+    static inline Math::real WGS84_a() { return WGS84_a<real>(); }
+    /**
+     * @tparam T the type of the returned value.
+     * @return the flattening of WGS84 ellipsoid (1/298.257223563).
+     **********************************************************************/
+    template<typename T> static inline 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 );
+    }
+    /**
+     * A synonym for WGS84_f<real>().
+     **********************************************************************/
+    static inline Math::real WGS84_f() { return WGS84_f<real>(); }
+    /**
+     * @tparam T the type of the returned value.
+     * @return the gravitational constant of the WGS84 ellipsoid, \e GM, in
+     *   m<sup>3</sup> s<sup>&minus;2</sup>.
+     **********************************************************************/
+    template<typename T> static inline T WGS84_GM()
+    { return T(3986004) * 100000000 + 41800000; }
+    /**
+     * A synonym for WGS84_GM<real>().
+     **********************************************************************/
+    static inline Math::real WGS84_GM() { return WGS84_GM<real>(); }
+    /**
+     * @tparam T the type of the returned value.
+     * @return the angular velocity of the WGS84 ellipsoid, &omega;, in rad
+     *   s<sup>&minus;1</sup>.
+     **********************************************************************/
+    template<typename T> static inline T WGS84_omega()
+    { return 7292115 / (T(1000000) * 100000); }
+    /**
+     * A synonym for WGS84_omega<real>().
+     **********************************************************************/
+    static inline Math::real WGS84_omega() { return WGS84_omega<real>(); }
+    /**
+     * @tparam T the type of the returned value.
+     * @return the equatorial radius of GRS80 ellipsoid, \e a, in m.
+     **********************************************************************/
+    template<typename T> static inline T GRS80_a()
+    { return 6378137 * meter<T>(); }
+    /**
+     * A synonym for GRS80_a<real>().
+     **********************************************************************/
+    static inline Math::real GRS80_a() { return GRS80_a<real>(); }
+    /**
+     * @tparam T the type of the returned value.
+     * @return the gravitational constant of the GRS80 ellipsoid, \e GM, in
+     *   m<sup>3</sup> s<sup>&minus;2</sup>.
+     **********************************************************************/
+    template<typename T> static inline T GRS80_GM()
+    { return T(3986005) * 100000000; }
+    /**
+     * A synonym for GRS80_GM<real>().
+     **********************************************************************/
+    static inline Math::real GRS80_GM() { return GRS80_GM<real>(); }
+    /**
+     * @tparam T the type of the returned value.
+     * @return the angular velocity of the GRS80 ellipsoid, &omega;, in rad
+     *   s<sup>&minus;1</sup>.
+     *
+     * This is about 2 &pi; 366.25 / (365.25 &times; 24 &times; 3600) rad
+     * s<sup>&minus;1</sup>.  365.25 is the number of days in a Julian year and
+     * 365.35/366.25 converts from solar days to sidereal days.  Using the
+     * number of days in a Gregorian year (365.2425) results in a worse
+     * approximation (because the Gregorian year includes the precession of the
+     * earth's axis).
+     **********************************************************************/
+    template<typename T> static inline T GRS80_omega()
+    { return 7292115 / (T(1000000) * 100000); }
+    /**
+     * A synonym for GRS80_omega<real>().
+     **********************************************************************/
+    static inline Math::real GRS80_omega() { return GRS80_omega<real>(); }
+    /**
+     * @tparam T the type of the returned value.
+     * @return the dynamical form factor of the GRS80 ellipsoid,
+     *   <i>J</i><sub>2</sub>.
+     **********************************************************************/
+    template<typename T> static inline T GRS80_J2()
+    { return T(108263) / 100000000; }
+    /**
+     * A synonym for GRS80_J2<real>().
+     **********************************************************************/
+    static inline Math::real GRS80_J2() { return GRS80_J2<real>(); }
+    /**
+     * @tparam T the type of the returned value.
+     * @return the central scale factor for UTM (0.9996).
+     **********************************************************************/
+    template<typename T> static inline T UTM_k0()
+    {return T(9996) / 10000; }
+    /**
+     * A synonym for UTM_k0<real>().
+     **********************************************************************/
+    static inline Math::real UTM_k0() { return UTM_k0<real>(); }
+    /**
+     * @tparam T the type of the returned value.
+     * @return the central scale factor for UPS (0.994).
+     **********************************************************************/
+    template<typename T> static inline T UPS_k0()
+    { return T(994) / 1000; }
+    /**
+     * A synonym for UPS_k0<real>().
+     **********************************************************************/
+    static inline Math::real UPS_k0() { return UPS_k0<real>(); }
+    ///@}
+
+    /** \name SI units
+     **********************************************************************/
+    ///@{
+    /**
+     * @tparam T the type of the returned value.
+     * @return the number of meters in a meter.
+     *
+     * This is unity, but this lets the internal system of units be changed if
+     * necessary.
+     **********************************************************************/
+    template<typename T> static inline T meter() { return T(1); }
+    /**
+     * A synonym for meter<real>().
+     **********************************************************************/
+    static inline Math::real meter() { return meter<real>(); }
+    /**
+     * @return the number of meters in a kilometer.
+     **********************************************************************/
+    static inline Math::real kilometer()
+    { return 1000 * meter<real>(); }
+    /**
+     * @return the number of meters in a nautical mile (approximately 1 arc
+     *   minute)
+     **********************************************************************/
+    static inline Math::real nauticalmile()
+    { return 1852 * meter<real>(); }
+
+    /**
+     * @tparam T the type of the returned value.
+     * @return the number of square meters in a square meter.
+     *
+     * This is unity, but this lets the internal system of units be changed if
+     * necessary.
+     **********************************************************************/
+    template<typename T> static inline T square_meter()
+    { return meter<real>() * meter<real>(); }
+    /**
+     * A synonym for square_meter<real>().
+     **********************************************************************/
+    static inline Math::real square_meter()
+    { return square_meter<real>(); }
+    /**
+     * @return the number of square meters in a hectare.
+     **********************************************************************/
+    static inline Math::real hectare()
+    { return 10000 * square_meter<real>(); }
+    /**
+     * @return the number of square meters in a square kilometer.
+     **********************************************************************/
+    static inline Math::real square_kilometer()
+    { return kilometer() * kilometer(); }
+    /**
+     * @return the number of square meters in a square nautical mile.
+     **********************************************************************/
+    static inline Math::real square_nauticalmile()
+    { return nauticalmile() * nauticalmile(); }
+    ///@}
+
+    /** \name Anachronistic British units
+     **********************************************************************/
+    ///@{
+    /**
+     * @return the number of meters in an international foot.
+     **********************************************************************/
+    static inline Math::real foot()
+    { return real(254 * 12) / 10000 * meter<real>(); }
+    /**
+     * @return the number of meters in a yard.
+     **********************************************************************/
+    static inline Math::real yard() { return 3 * foot(); }
+    /**
+     * @return the number of meters in a fathom.
+     **********************************************************************/
+    static inline Math::real fathom() { return 2 * yard(); }
+    /**
+     * @return the number of meters in a chain.
+     **********************************************************************/
+    static inline Math::real chain() { return 22 * yard(); }
+    /**
+     * @return the number of meters in a furlong.
+     **********************************************************************/
+    static inline Math::real furlong() { return 10 * chain(); }
+    /**
+     * @return the number of meters in a statute mile.
+     **********************************************************************/
+    static inline Math::real mile() { return 8 * furlong(); }
+    /**
+     * @return the number of square meters in an acre.
+     **********************************************************************/
+    static inline Math::real acre() { return chain() * furlong(); }
+    /**
+     * @return the number of square meters in a square statute mile.
+     **********************************************************************/
+    static inline Math::real square_mile() { return mile() * mile(); }
+    ///@}
+
+    /** \name Anachronistic US units
+     **********************************************************************/
+    ///@{
+    /**
+     * @return the number of meters in a US survey foot.
+     **********************************************************************/
+    static inline Math::real surveyfoot()
+    { return real(1200) / 3937 * meter<real>(); }
+    ///@}
+  };
+
+  /**
+   * \brief Exception handling for %GeographicLib
+   *
+   * A class to handle exceptions.  It's derived from std::runtime_error so it
+   * can be caught by the usual catch clauses.
+   *
+   * Example of use:
+   * \include example-GeographicErr.cpp
+   **********************************************************************/
+  class GeographicErr : public std::runtime_error {
+  public:
+
+    /**
+     * Constructor
+     *
+     * @param[in] msg a string message, which is accessible in the catch
+     *   clause via what().
+     **********************************************************************/
+    GeographicErr(const std::string& msg) : std::runtime_error(msg) {}
+  };
+
+} // namespace GeographicLib
+
+#endif  // GEOGRAPHICLIB_CONSTANTS_HPP

data/ext/geographiclib/GeographicLib/DMS.hpp

@@ -0,0 +1,370 @@
+/**
+ * \file DMS.hpp
+ * \brief Header for GeographicLib::DMS class
+ *
+ * Copyright (c) Charles Karney (2008-2015) <charles@karney.com> and licensed
+ * under the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#if !defined(GEOGRAPHICLIB_DMS_HPP)
+#define GEOGRAPHICLIB_DMS_HPP 1
+
+#include <GeographicLib/Constants.hpp>
+#include <GeographicLib/Utility.hpp>
+
+#if defined(_MSC_VER)
+// Squelch warnings about dll vs vector and constant conditional expressions
+#  pragma warning (push)
+#  pragma warning (disable: 4251 4127)
+#endif
+
+namespace GeographicLib {
+
+  /**
+   * \brief Convert between degrees and the %DMS representation
+   *
+   * Parse a string representing degree, minutes, and seconds and return the
+   * angle in degrees and format an angle in degrees as degree, minutes, and
+   * seconds.  In addition, handle NANs and infinities on input and output.
+   *
+   * Example of use:
+   * \include example-DMS.cpp
+   **********************************************************************/
+  class GEOGRAPHICLIB_EXPORT DMS {
+  public:
+
+    /**
+     * Indicator for presence of hemisphere indicator (N/S/E/W) on latitudes
+     * and longitudes.
+     **********************************************************************/
+    enum flag {
+      /**
+       * No indicator present.
+       * @hideinitializer
+       **********************************************************************/
+      NONE = 0,
+      /**
+       * Latitude indicator (N/S) present.
+       * @hideinitializer
+       **********************************************************************/
+      LATITUDE = 1,
+      /**
+       * Longitude indicator (E/W) present.
+       * @hideinitializer
+       **********************************************************************/
+      LONGITUDE = 2,
+      /**
+       * Used in Encode to indicate output of an azimuth in [000, 360) with no
+       * letter indicator.
+       * @hideinitializer
+       **********************************************************************/
+      AZIMUTH = 3,
+      /**
+       * Used in Encode to indicate output of a plain number.
+       * @hideinitializer
+       **********************************************************************/
+      NUMBER = 4,
+    };
+
+    /**
+     * Indicator for trailing units on an angle.
+     **********************************************************************/
+    enum component {
+      /**
+       * Trailing unit is degrees.
+       * @hideinitializer
+       **********************************************************************/
+      DEGREE = 0,
+      /**
+       * Trailing unit is arc minutes.
+       * @hideinitializer
+       **********************************************************************/
+      MINUTE = 1,
+      /**
+       * Trailing unit is arc seconds.
+       * @hideinitializer
+       **********************************************************************/
+      SECOND = 2,
+    };
+
+  private:
+    typedef Math::real real;
+    // Replace all occurrences of pat by c
+    static void replace(std::string& s, const std::string& pat, char c) {
+      std::string::size_type p = 0;
+      while (true) {
+        p = s.find(pat, p);
+        if (p == std::string::npos)
+          break;
+        s.replace(p, pat.length(), 1, c);
+      }
+    }
+    static const std::string hemispheres_;
+    static const std::string signs_;
+    static const std::string digits_;
+    static const std::string dmsindicators_;
+    static const std::string components_[3];
+    static Math::real NumMatch(const std::string& s);
+    static Math::real InternalDecode(const std::string& dmsa, flag& ind);
+    DMS();                      // Disable constructor
+
+  public:
+
+    /**
+     * Convert a string in DMS to an angle.
+     *
+     * @param[in] dms string input.
+     * @param[out] ind a DMS::flag value signaling the presence of a
+     *   hemisphere indicator.
+     * @exception GeographicErr if \e dms is malformed (see below).
+     * @return angle (degrees).
+     *
+     * Degrees, minutes, and seconds are indicated by the characters d, '
+     * (single quote), &quot; (double quote), and these components may only be
+     * given in this order.  Any (but not all) components may be omitted and
+     * other symbols (e.g., the &deg; symbol for degrees and the unicode prime
+     * and double prime symbols for minutes and seconds) may be substituted;
+     * two single quotes can be used instead of &quot;.  The last component
+     * indicator may be omitted and is assumed to be the next smallest unit
+     * (thus 33d10 is interpreted as 33d10').  The final component may be a
+     * decimal fraction but the non-final components must be integers.  Instead
+     * of using d, ', and &quot; to indicate degrees, minutes, and seconds, :
+     * (colon) may be used to <i>separate</i> these components (numbers must
+     * appear before and after each colon); thus 50d30'10.3&quot; may be
+     * written as 50:30:10.3, 5.5' may be written 0:5.5, and so on.  The
+     * integer parts of the minutes and seconds components must be less
+     * than 60.  A single leading sign is permitted.  A hemisphere designator
+     * (N, E, W, S) may be added to the beginning or end of the string.  The
+     * result is multiplied by the implied sign of the hemisphere designator
+     * (negative for S and W).  In addition \e ind is set to DMS::LATITUDE if N
+     * or S is present, to DMS::LONGITUDE if E or W is present, and to
+     * DMS::NONE otherwise.  Throws an error on a malformed string.  No check
+     * is performed on the range of the result.  Examples of legal and illegal
+     * strings are
+     * - <i>LEGAL</i> (all the entries on each line are equivalent)
+     *   - -20.51125, 20d30'40.5&quot;S, -20&deg;30'40.5, -20d30.675,
+     *     N-20d30'40.5&quot;, -20:30:40.5
+     *   - 4d0'9, 4d9&quot;, 4d9'', 4:0:9, 004:00:09, 4.0025, 4.0025d, 4d0.15,
+     *     04:.15
+     *   - 4:59.99999999999999, 4:60.0, 4:59:59.9999999999999, 4:59:60.0, 5
+     * - <i>ILLEGAL</i> (the exception thrown explains the problem)
+     *   - 4d5&quot;4', 4::5, 4:5:, :4:5, 4d4.5'4&quot;, -N20.5, 1.8e2d, 4:60,
+     *     4:59:60
+     *
+     * The decoding operation can also perform addition and subtraction
+     * operations.  If the string includes <i>internal</i> signs (i.e., not at
+     * the beginning nor immediately after an initial hemisphere designator),
+     * then the string is split immediately before such signs and each piece is
+     * decoded according to the above rules and the results added; thus
+     * <code>S3-2.5+4.1N</code> is parsed as the sum of <code>S3</code>,
+     * <code>-2.5</code>, <code>+4.1N</code>.  Any piece can include a
+     * hemisphere designator; however, if multiple designators are given, they
+     * must compatible; e.g., you cannot mix N and E.  In addition, the
+     * designator can appear at the beginning or end of the first piece, but
+     * must be at the end of all subsequent pieces (a hemisphere designator is
+     * not allowed after the initial sign).  Examples of legal and illegal
+     * combinations are
+     * - <i>LEGAL</i> (these are all equivalent)
+     *   - 070:00:45, 70:01:15W+0:0.5, 70:01:15W-0:0:30W, W70:01:15+0:0:30E
+     * - <i>ILLEGAL</i> (the exception thrown explains the problem)
+     *   - 70:01:15W+0:0:15N, W70:01:15+W0:0:15
+     *
+     * <b>WARNING:</b> "Exponential" notation is not recognized.  Thus
+     * <code>7.0E1</code> is illegal, while <code>7.0E+1</code> is parsed as
+     * <code>(7.0E) + (+1)</code>, yielding the same result as
+     * <code>8.0E</code>.
+     *
+     * <b>NOTE:</b> At present, all the string handling in the C++
+     * implementation %GeographicLib is with 8-bit characters.  The support for
+     * unicode symbols for degrees, minutes, and seconds is therefore via the
+     * <a href="https://en.wikipedia.org/wiki/UTF-8">UTF-8</a> encoding.  (The
+     * JavaScript implementation of this class uses unicode natively, of
+     * course.)
+     *
+     * Here is the list of Unicode symbols supported for degrees, minutes,
+     * seconds, and the sign:
+     * - degrees:
+     *   - d, D lower and upper case letters
+     *   - U+00b0 degree symbol (&deg;)
+     *   - U+00ba masculine ordinal indicator
+     *   - U+2070 superscript zero
+     *   - U+02da ring above
+     * - minutes:
+     *   - ' apostrophe
+     *   - U+2032 prime (&prime;)
+     *   - U+00b4 acute accent
+     *   - U+2019 right single quote (&rsquo;)
+     * - seconds:
+     *   - &quot; quotation mark
+     *   - U+2033 double prime (&Prime;)
+     *   - U+201d right double quote (&rdquo;)
+     *   - '&nbsp;' any two consecutive symbols for minutes
+     * - leading sign:
+     *   - U+2212 minus sign (&minus;)
+     * .
+     * The codes with a leading zero byte, e.g., U+00b0, are accepted in their
+     * UTF-8 coded form 0xc2 0xb0 and as a single byte 0xb0.
+     **********************************************************************/
+    static Math::real Decode(const std::string& dms, flag& ind);
+
+    /**
+     * Convert DMS to an angle.
+     *
+     * @param[in] d degrees.
+     * @param[in] m arc minutes.
+     * @param[in] s arc seconds.
+     * @return angle (degrees)
+     *
+     * This does not propagate the sign on \e d to the other components,
+     * so -3d20' would need to be represented as - DMS::Decode(3.0, 20.0) or
+     * DMS::Decode(-3.0, -20.0).
+     **********************************************************************/
+    static Math::real Decode(real d, real m = 0, real s = 0)
+    { return d + (m + s / 60) / 60; }
+
+    /**
+     * Convert a pair of strings to latitude and longitude.
+     *
+     * @param[in] dmsa first string.
+     * @param[in] dmsb second string.
+     * @param[out] lat latitude (degrees).
+     * @param[out] lon longitude (degrees).
+     * @param[in] longfirst if true assume longitude is given before latitude
+     *   in the absence of hemisphere designators (default false).
+     * @exception GeographicErr if \e dmsa or \e dmsb is malformed.
+     * @exception GeographicErr if \e dmsa and \e dmsb are both interpreted as
+     *   latitudes.
+     * @exception GeographicErr if \e dmsa and \e dmsb are both interpreted as
+     *   longitudes.
+     * @exception GeographicErr if decoded latitude is not in [&minus;90&deg;,
+     *   90&deg;].
+     *
+     * By default, the \e lat (resp., \e lon) is assigned to the results of
+     * decoding \e dmsa (resp., \e dmsb).  However this is overridden if either
+     * \e dmsa or \e dmsb contain a latitude or longitude hemisphere designator
+     * (N, S, E, W).  If an exception is thrown, \e lat and \e lon are
+     * unchanged.
+     **********************************************************************/
+    static void DecodeLatLon(const std::string& dmsa, const std::string& dmsb,
+                             real& lat, real& lon,
+                             bool longfirst = false);
+
+    /**
+     * Convert a string to an angle in degrees.
+     *
+     * @param[in] angstr input string.
+     * @exception GeographicErr if \e angstr is malformed.
+     * @exception GeographicErr if \e angstr includes a hemisphere designator.
+     * @return angle (degrees)
+     *
+     * No hemisphere designator is allowed and no check is done on the range of
+     * the result.
+     **********************************************************************/
+    static Math::real DecodeAngle(const std::string& angstr);
+
+    /**
+     * Convert a string to an azimuth in degrees.
+     *
+     * @param[in] azistr input string.
+     * @exception GeographicErr if \e azistr is malformed.
+     * @exception GeographicErr if \e azistr includes a N/S designator.
+     * @return azimuth (degrees) reduced to the range [&minus;180&deg;,
+     *   180&deg;).
+     *
+     * A hemisphere designator E/W can be used; the result is multiplied by
+     * &minus;1 if W is present.
+     **********************************************************************/
+    static Math::real DecodeAzimuth(const std::string& azistr);
+
+    /**
+     * Convert angle (in degrees) into a DMS string (using d, ', and &quot;).
+     *
+     * @param[in] angle input angle (degrees)
+     * @param[in] trailing DMS::component value indicating the trailing units
+     *   of the string (this component is given as a decimal number if
+     *   necessary).
+     * @param[in] prec the number of digits after the decimal point for the
+     *   trailing component.
+     * @param[in] ind DMS::flag value indicating additional formatting.
+     * @param[in] dmssep if non-null, use as the DMS separator character
+     *   (instead of d, ', &quot; delimiters).
+     * @exception std::bad_alloc if memory for the string can't be allocated.
+     * @return formatted string
+     *
+     * The interpretation of \e ind is as follows:
+     * - ind == DMS::NONE, signed result no leading zeros on degrees except in
+     *   the units place, e.g., -8d03'.
+     * - ind == DMS::LATITUDE, trailing N or S hemisphere designator, no sign,
+     *   pad degrees to 2 digits, e.g., 08d03'S.
+     * - ind == DMS::LONGITUDE, trailing E or W hemisphere designator, no
+     *   sign, pad degrees to 3 digits, e.g., 008d03'W.
+     * - ind == DMS::AZIMUTH, convert to the range [0, 360&deg;), no
+     *   sign, pad degrees to 3 digits, e.g., 351d57'.
+     * .
+     * The integer parts of the minutes and seconds components are always given
+     * with 2 digits.
+     **********************************************************************/
+    static std::string Encode(real angle, component trailing, unsigned prec,
+                              flag ind = NONE, char dmssep = char(0));
+
+    /**
+     * Convert angle into a DMS string (using d, ', and &quot;) selecting the
+     * trailing component based on the precision.
+     *
+     * @param[in] angle input angle (degrees)
+     * @param[in] prec the precision relative to 1 degree.
+     * @param[in] ind DMS::flag value indicated additional formatting.
+     * @param[in] dmssep if non-null, use as the DMS separator character
+     *   (instead of d, ', &quot; delimiters).
+     * @exception std::bad_alloc if memory for the string can't be allocated.
+     * @return formatted string
+     *
+     * \e prec indicates the precision relative to 1 degree, e.g., \e prec = 3
+     * gives a result accurate to 0.1' and \e prec = 4 gives a result accurate
+     * to 1&quot;.  \e ind is interpreted as in DMS::Encode with the additional
+     * facility that DMS::NUMBER represents \e angle as a number in fixed
+     * format with precision \e prec.
+     **********************************************************************/
+    static std::string Encode(real angle, unsigned prec, flag ind = NONE,
+                              char dmssep = char(0)) {
+      return ind == NUMBER ? Utility::str(angle, int(prec)) :
+        Encode(angle,
+               prec < 2 ? DEGREE : (prec < 4 ? MINUTE : SECOND),
+               prec < 2 ? prec : (prec < 4 ? prec - 2 : prec - 4),
+               ind, dmssep);
+    }
+
+    /**
+     * Split angle into degrees and minutes
+     *
+     * @param[in] ang angle (degrees)
+     * @param[out] d degrees (an integer returned as a real)
+     * @param[out] m arc minutes.
+     **********************************************************************/
+    static void Encode(real ang, real& d, real& m) {
+      d = int(ang); m = 60 * (ang - d);
+    }
+
+    /**
+     * Split angle into degrees and minutes and seconds.
+     *
+     * @param[in] ang angle (degrees)
+     * @param[out] d degrees (an integer returned as a real)
+     * @param[out] m arc minutes (an integer returned as a real)
+     * @param[out] s arc seconds.
+     **********************************************************************/
+    static void Encode(real ang, real& d, real& m, real& s) {
+      d = int(ang); ang = 60 * (ang - d);
+      m = int(ang); s = 60 * (ang - m);
+    }
+
+  };
+
+} // namespace GeographicLib
+
+#if defined(_MSC_VER)
+#  pragma warning (pop)
+#endif
+
+#endif  // GEOGRAPHICLIB_DMS_HPP