GeographicLib 2.3

DMS.cpp
Go to the documentation of this file.
1/**
2 * \file DMS.cpp
3 * \brief Implementation for GeographicLib::DMS class
4 *
5 * Copyright (c) Charles Karney (2008-2022) <karney@alum.mit.edu> and licensed
6 * under the MIT/X11 License. For more information, see
7 * https://geographiclib.sourceforge.io/
8 **********************************************************************/
9
10#include <GeographicLib/DMS.hpp>
11#include <GeographicLib/Utility.hpp>
12
13#if defined(_MSC_VER)
14// Squelch warnings about constant conditional and enum-float expressions
15# pragma warning (disable: 4127 5055)
16#endif
17
18 namespace GeographicLib {
19
20 using namespace std;
21
22 const char* const DMS::hemispheres_ = "SNWE";
23 const char* const DMS::signs_ = "-+";
24 const char* const DMS::digits_ = "0123456789";
25 const char* const DMS::dmsindicators_ = "D'\":";
26 const char* const DMS::components_[] = {"degrees", "minutes", "seconds"};
27
28 // Replace all occurrences of pat by c. If c is NULL remove pat.
29 void DMS::replace(std::string& s, const std::string& pat, char c) {
30 string::size_type p = 0;
31 int count = c ? 1 : 0;
32 while (true) {
33 p = s.find(pat, p);
34 if (p == string::npos)
35 break;
36 s.replace(p, pat.length(), count, c);
37 }
38 }
39
40 Math::real DMS::Decode(const std::string& dms, flag& ind) {
41 // Here's a table of the allowed characters
42
43 // S unicode dec UTF-8 descripton
44
45 // DEGREE
46 // d U+0064 100 64 d
47 // D U+0044 68 44 D
48 // ° U+00b0 176 c2 b0 degree symbol
49 // º U+00ba 186 c2 ba alt symbol
50 // ⁰ U+2070 8304 e2 81 b0 sup zero
51 // ˚ U+02da 730 cb 9a ring above
52 // ∘ U+2218 8728 e2 88 98 compose function
53 // * U+002a 42 2a GRiD symbol for degrees
54
55 // MINUTES
56 // ' U+0027 39 27 apostrophe
57 // ` U+0060 96 60 grave accent
58 // ′ U+2032 8242 e2 80 b2 prime
59 // ‵ U+2035 8245 e2 80 b5 back prime
60 // ´ U+00b4 180 c2 b4 acute accent
61 // ‘ U+2018 8216 e2 80 98 left single quote (also ext ASCII 0x91)
62 // ’ U+2019 8217 e2 80 99 right single quote (also ext ASCII 0x92)
63 // ‛ U+201b 8219 e2 80 9b reversed-9 single quote
64 // ʹ U+02b9 697 ca b9 modifier letter prime
65 // ˊ U+02ca 714 cb 8a modifier letter acute accent
66 // ˋ U+02cb 715 cb 8b modifier letter grave accent
67
68 // SECONDS
69 // " U+0022 34 22 quotation mark
70 // ″ U+2033 8243 e2 80 b3 double prime
71 // ‶ U+2036 8246 e2 80 b6 reversed double prime
72 // ˝ U+02dd 733 cb 9d double acute accent
73 // “ U+201c 8220 e2 80 9c left double quote (also ext ASCII 0x93)
74 // ” U+201d 8221 e2 80 9d right double quote (also ext ASCII 0x94)
75 // ‟ U+201f 8223 e2 80 9f reversed-9 double quote
76 // ʺ U+02ba 698 ca ba modifier letter double prime
77
78 // PLUS
79 // + U+002b 43 2b plus sign
80 // ➕ U+2795 10133 e2 9e 95 heavy plus
81 // U+2064 8292 e2 81 a4 invisible plus |⁤|
82
83 // MINUS
84 // - U+002d 45 2d hyphen
85 // ‐ U+2010 8208 e2 80 90 dash
86 // ‑ U+2011 8209 e2 80 91 non-breaking hyphen
87 // – U+2013 8211 e2 80 93 en dash (also ext ASCII 0x96)
88 // — U+2014 8212 e2 80 94 em dash (also ext ASCII 0x97)
89 // − U+2212 8722 e2 88 92 minus sign
90 // ➖ U+2796 10134 e2 9e 96 heavy minus
91
92 // IGNORED
93 // U+00a0 160 c2 a0 non-breaking space
94 // U+2007 8199 e2 80 87 figure space | |
95 // U+2009 8201 e2 80 89 thin space | |
96 // U+200a 8202 e2 80 8a hair space | |
97 // U+200b 8203 e2 80 8b invisible space |​|
98 //   U+202f 8239 e2 80 af narrow space | |
99 // U+2063 8291 e2 81 a3 invisible separator |⁣|
100 // « U+00ab 171 c2 ab left guillemot (for cgi-bin)
101 // » U+00bb 187 c2 bb right guillemot (for cgi-bin)
102
103 string dmsa = dms;
104 replace(dmsa, "\xc2\xb0", 'd' ); // U+00b0 degree symbol
105 replace(dmsa, "\xc2\xba", 'd' ); // U+00ba alt symbol
106 replace(dmsa, "\xe2\x81\xb0", 'd' ); // U+2070 sup zero
107 replace(dmsa, "\xcb\x9a", 'd' ); // U+02da ring above
108 replace(dmsa, "\xe2\x88\x98", 'd' ); // U+2218 compose function
109
110 replace(dmsa, "\xe2\x80\xb2", '\''); // U+2032 prime
111 replace(dmsa, "\xe2\x80\xb5", '\''); // U+2035 back prime
112 replace(dmsa, "\xc2\xb4", '\''); // U+00b4 acute accent
113 replace(dmsa, "\xe2\x80\x98", '\''); // U+2018 left single quote
114 replace(dmsa, "\xe2\x80\x99", '\''); // U+2019 right single quote
115 replace(dmsa, "\xe2\x80\x9b", '\''); // U+201b reversed-9 single quote
116 replace(dmsa, "\xca\xb9", '\''); // U+02b9 modifier letter prime
117 replace(dmsa, "\xcb\x8a", '\''); // U+02ca modifier letter acute accent
118 replace(dmsa, "\xcb\x8b", '\''); // U+02cb modifier letter grave accent
119
120 replace(dmsa, "\xe2\x80\xb3", '"' ); // U+2033 double prime
121 replace(dmsa, "\xe2\x80\xb6", '"' ); // U+2036 reversed double prime
122 replace(dmsa, "\xcb\x9d", '"' ); // U+02dd double acute accent
123 replace(dmsa, "\xe2\x80\x9c", '"' ); // U+201c left double quote
124 replace(dmsa, "\xe2\x80\x9d", '"' ); // U+201d right double quote
125 replace(dmsa, "\xe2\x80\x9f", '"' ); // U+201f reversed-9 double quote
126 replace(dmsa, "\xca\xba", '"' ); // U+02ba modifier letter double prime
127
128 replace(dmsa, "\xe2\x9e\x95", '+' ); // U+2795 heavy plus
129 replace(dmsa, "\xe2\x81\xa4", '+' ); // U+2064 invisible plus
130
131 replace(dmsa, "\xe2\x80\x90", '-' ); // U+2010 dash
132 replace(dmsa, "\xe2\x80\x91", '-' ); // U+2011 non-breaking hyphen
133 replace(dmsa, "\xe2\x80\x93", '-' ); // U+2013 en dash
134 replace(dmsa, "\xe2\x80\x94", '-' ); // U+2014 em dash
135 replace(dmsa, "\xe2\x88\x92", '-' ); // U+2212 minus sign
136 replace(dmsa, "\xe2\x9e\x96", '-' ); // U+2796 heavy minus
137
138 replace(dmsa, "\xc2\xa0", '\0'); // U+00a0 non-breaking space
139 replace(dmsa, "\xe2\x80\x87", '\0'); // U+2007 figure space
140 replace(dmsa, "\xe2\x80\x89", '\0'); // U+2007 thin space
141 replace(dmsa, "\xe2\x80\x8a", '\0'); // U+200a hair space
142 replace(dmsa, "\xe2\x80\x8b", '\0'); // U+200b invisible space
143 replace(dmsa, "\xe2\x80\xaf", '\0'); // U+202f narrow space
144 replace(dmsa, "\xe2\x81\xa3", '\0'); // U+2063 invisible separator
145
146 replace(dmsa, "\xb0", 'd' ); // 0xb0 bare degree symbol
147 replace(dmsa, "\xba", 'd' ); // 0xba bare alt symbol
148 replace(dmsa, "*", 'd' ); // GRiD symbol for degree
149 replace(dmsa, "`", '\''); // grave accent
150 replace(dmsa, "\xb4", '\''); // 0xb4 bare acute accent
151 // Don't implement these alternatives; they are only relevant for cgi-bin
152 // replace(dmsa, "\x91", '\''); // 0x91 ext ASCII left single quote
153 // replace(dmsa, "\x92", '\''); // 0x92 ext ASCII right single quote
154 // replace(dmsa, "\x93", '"' ); // 0x93 ext ASCII left double quote
155 // replace(dmsa, "\x94", '"' ); // 0x94 ext ASCII right double quote
156 // replace(dmsa, "\x96", '-' ); // 0x96 ext ASCII en dash
157 // replace(dmsa, "\x97", '-' ); // 0x97 ext ASCII em dash
158 replace(dmsa, "\xa0", '\0'); // 0xa0 bare non-breaking space
159 replace(dmsa, "''", '"' ); // '' -> "
160 string::size_type
161 beg = 0,
162 end = unsigned(dmsa.size());
163 while (beg < end && isspace(dmsa[beg]))
164 ++beg;
165 while (beg < end && isspace(dmsa[end - 1]))
166 --end;
167 // The trimmed string in [beg, end)
168 real v = -0.0; // So "-0" returns -0.0
169 int i = 0;
170 flag ind1 = NONE;
171 // p is pointer to the next piece that needs decoding
172 for (string::size_type p = beg, pb; p < end; p = pb, ++i) {
173 string::size_type pa = p;
174 // Skip over initial hemisphere letter (for i == 0)
175 if (i == 0 && Utility::lookup(hemispheres_, dmsa[pa]) >= 0)
176 ++pa;
177 // Skip over initial sign (checking for it if i == 0)
178 if (i > 0 || (pa < end && Utility::lookup(signs_, dmsa[pa]) >= 0))
179 ++pa;
180 // Find next sign
181 pb = min(dmsa.find_first_of(signs_, pa), end);
182 flag ind2 = NONE;
183 v += InternalDecode(dmsa.substr(p, pb - p), ind2);
184 if (ind1 == NONE)
185 ind1 = ind2;
186 else if (!(ind2 == NONE || ind1 == ind2))
187 throw GeographicErr("Incompatible hemisphere specifier in " +
188 dmsa.substr(beg, pb - beg));
189 }
190 if (i == 0)
191 throw GeographicErr("Empty or incomplete DMS string " +
192 dmsa.substr(beg, end - beg));
193 ind = ind1;
194 return v;
195 }
196
197 Math::real DMS::InternalDecode(const string& dmsa, flag& ind) {
198 string errormsg;
199 do { // Executed once (provides the ability to break)
200 int sign = 1;
201 unsigned
202 beg = 0,
203 end = unsigned(dmsa.size());
204 flag ind1 = NONE;
205 int k = -1;
206 if (end > beg && (k = Utility::lookup(hemispheres_, dmsa[beg])) >= 0) {
207 ind1 = (k / 2) ? LONGITUDE : LATITUDE;
208 sign = k % 2 ? 1 : -1;
209 ++beg;
210 }
211 if (end > beg && (k = Utility::lookup(hemispheres_, dmsa[end-1])) >= 0) {
212 if (k >= 0) {
213 if (ind1 != NONE) {
214 if (toupper(dmsa[beg - 1]) == toupper(dmsa[end - 1]))
215 errormsg = "Repeated hemisphere indicators "
216 + Utility::str(dmsa[beg - 1])
217 + " in " + dmsa.substr(beg - 1, end - beg + 1);
218 else
219 errormsg = "Contradictory hemisphere indicators "
220 + Utility::str(dmsa[beg - 1]) + " and "
221 + Utility::str(dmsa[end - 1]) + " in "
222 + dmsa.substr(beg - 1, end - beg + 1);
223 break;
224 }
225 ind1 = (k / 2) ? LONGITUDE : LATITUDE;
226 sign = k % 2 ? 1 : -1;
227 --end;
228 }
229 }
230 if (end > beg && (k = Utility::lookup(signs_, dmsa[beg])) >= 0) {
231 if (k >= 0) {
232 sign *= k ? 1 : -1;
233 ++beg;
234 }
235 }
236 if (end == beg) {
237 errormsg = "Empty or incomplete DMS string " + dmsa;
238 break;
239 }
240 real ipieces[] = {0, 0, 0};
241 real fpieces[] = {0, 0, 0};
242 unsigned npiece = 0;
243 real icurrent = 0;
244 real fcurrent = 0;
245 unsigned ncurrent = 0, p = beg;
246 bool pointseen = false;
247 unsigned digcount = 0, intcount = 0;
248 while (p < end) {
249 char x = dmsa[p++];
250 if ((k = Utility::lookup(digits_, x)) >= 0) {
251 ++ncurrent;
252 if (digcount > 0)
253 ++digcount; // Count of decimal digits
254 else {
255 icurrent = 10 * icurrent + k;
256 ++intcount;
257 }
258 } else if (x == '.') {
259 if (pointseen) {
260 errormsg = "Multiple decimal points in "
261 + dmsa.substr(beg, end - beg);
262 break;
263 }
264 pointseen = true;
265 digcount = 1;
266 } else if ((k = Utility::lookup(dmsindicators_, x)) >= 0) {
267 if (k >= 3) {
268 if (p == end) {
269 errormsg = "Illegal for : to appear at the end of " +
270 dmsa.substr(beg, end - beg);
271 break;
272 }
273 k = npiece;
274 }
275 if (unsigned(k) == npiece - 1) {
276 errormsg = "Repeated " + string(components_[k]) +
277 " component in " + dmsa.substr(beg, end - beg);
278 break;
279 } else if (unsigned(k) < npiece) {
280 errormsg = string(components_[k]) + " component follows "
281 + string(components_[npiece - 1]) + " component in "
282 + dmsa.substr(beg, end - beg);
283 break;
284 }
285 if (ncurrent == 0) {
286 errormsg = "Missing numbers in " + string(components_[k]) +
287 " component of " + dmsa.substr(beg, end - beg);
288 break;
289 }
290 if (digcount > 0) {
291 istringstream s(dmsa.substr(p - intcount - digcount - 1,
292 intcount + digcount));
293 s >> fcurrent;
294 icurrent = 0;
295 }
296 ipieces[k] = icurrent;
297 fpieces[k] = icurrent + fcurrent;
298 if (p < end) {
299 npiece = k + 1;
300 icurrent = fcurrent = 0;
301 ncurrent = digcount = intcount = 0;
302 }
303 } else if (Utility::lookup(signs_, x) >= 0) {
304 errormsg = "Internal sign in DMS string "
305 + dmsa.substr(beg, end - beg);
306 break;
307 } else {
308 errormsg = "Illegal character " + Utility::str(x) + " in DMS string "
309 + dmsa.substr(beg, end - beg);
310 break;
311 }
312 }
313 if (!errormsg.empty())
314 break;
315 if (Utility::lookup(dmsindicators_, dmsa[p - 1]) < 0) {
316 if (npiece >= 3) {
317 errormsg = "Extra text following seconds in DMS string "
318 + dmsa.substr(beg, end - beg);
319 break;
320 }
321 if (ncurrent == 0) {
322 errormsg = "Missing numbers in trailing component of "
323 + dmsa.substr(beg, end - beg);
324 break;
325 }
326 if (digcount > 0) {
327 istringstream s(dmsa.substr(p - intcount - digcount,
328 intcount + digcount));
329 s >> fcurrent;
330 icurrent = 0;
331 }
332 ipieces[npiece] = icurrent;
333 fpieces[npiece] = icurrent + fcurrent;
334 }
335 if (pointseen && digcount == 0) {
336 errormsg = "Decimal point in non-terminal component of "
337 + dmsa.substr(beg, end - beg);
338 break;
339 }
340 // Note that we accept 59.999999... even though it rounds to 60.
341 if (ipieces[1] >= Math::dm || fpieces[1] > Math::dm ) {
342 errormsg = "Minutes " + Utility::str(fpieces[1])
343 + " not in range [0, " + to_string(Math::dm) + ")";
344 break;
345 }
346 if (ipieces[2] >= Math::ms || fpieces[2] > Math::ms) {
347 errormsg = "Seconds " + Utility::str(fpieces[2])
348 + " not in range [0, " + to_string(Math::ms) + ")";
349 break;
350 }
351 ind = ind1;
352 // Assume check on range of result is made by calling routine (which
353 // might be able to offer a better diagnostic).
354 return real(sign) *
355 ( fpieces[2] != 0 ?
356 (Math::ms*(Math::dm*fpieces[0] + fpieces[1]) + fpieces[2])/Math::ds :
357 ( fpieces[1] != 0 ?
358 (Math::dm*fpieces[0] + fpieces[1]) / Math::dm : fpieces[0] ) );
359 } while (false);
360 real val = Utility::nummatch<real>(dmsa);
361 if (val == 0)
362 throw GeographicErr(errormsg);
363 else
364 ind = NONE;
365 return val;
366 }
367
368 void DMS::DecodeLatLon(const string& stra, const string& strb,
369 real& lat, real& lon,
370 bool longfirst) {
371 real a, b;
372 flag ia, ib;
373 a = Decode(stra, ia);
374 b = Decode(strb, ib);
375 if (ia == NONE && ib == NONE) {
376 // Default to lat, long unless longfirst
377 ia = longfirst ? LONGITUDE : LATITUDE;
378 ib = longfirst ? LATITUDE : LONGITUDE;
379 } else if (ia == NONE)
380 ia = flag(LATITUDE + LONGITUDE - ib);
381 else if (ib == NONE)
382 ib = flag(LATITUDE + LONGITUDE - ia);
383 if (ia == ib)
384 throw GeographicErr("Both " + stra + " and "
385 + strb + " interpreted as "
386 + (ia == LATITUDE ? "latitudes" : "longitudes"));
387 real
388 lat1 = ia == LATITUDE ? a : b,
389 lon1 = ia == LATITUDE ? b : a;
390 if (fabs(lat1) > Math::qd)
391 throw GeographicErr("Latitude " + Utility::str(lat1)
392 + "d not in [-" + to_string(Math::qd)
393 + "d, " + to_string(Math::qd) + "d]");
394 lat = lat1;
395 lon = lon1;
396 }
397
398 Math::real DMS::DecodeAngle(const string& angstr) {
399 flag ind;
400 real ang = Decode(angstr, ind);
401 if (ind != NONE)
402 throw GeographicErr("Arc angle " + angstr
403 + " includes a hemisphere, N/E/W/S");
404 return ang;
405 }
406
407 Math::real DMS::DecodeAzimuth(const string& azistr) {
408 flag ind;
409 real azi = Decode(azistr, ind);
410 if (ind == LATITUDE)
411 throw GeographicErr("Azimuth " + azistr
412 + " has a latitude hemisphere, N/S");
413 return Math::AngNormalize(azi);
414 }
415
416 string DMS::Encode(real angle, component trailing, unsigned prec, flag ind,
417 char dmssep) {
418 // Assume check on range of input angle has been made by calling
419 // routine (which might be able to offer a better diagnostic).
420 if (!isfinite(angle))
421 return angle < 0 ? string("-inf") :
422 (angle > 0 ? string("inf") : string("nan"));
423
424 // 15 - 2 * trailing = ceiling(log10(2^53/90/60^trailing)).
425 // This suffices to give full real precision for numbers in [-90,90]
426 prec = min(15 + Math::extra_digits() - 2 * unsigned(trailing), prec);
427 real scale = trailing == MINUTE ? Math::dm :
428 (trailing == SECOND ? Math::ds : 1);
429 if (ind == AZIMUTH) {
430 angle = Math::AngNormalize(angle);
431 // Only angles strictly less than 0 can become 360; since +/-180 are
432 // folded together, we convert -0 to +0 (instead of 360).
433 if (angle < 0)
434 angle += Math::td;
435 else
436 angle = Math::real(0) + angle;
437 }
438 int sign = signbit(angle) ? -1 : 1;
439 angle *= sign;
440
441 // Break off integer part to preserve precision and avoid overflow in
442 // manipulation of fractional part for MINUTE and SECOND
443 real
444 idegree = trailing == DEGREE ? 0 : floor(angle),
445 fdegree = (angle - idegree) * scale;
446 string s = Utility::str(fdegree, prec), degree, minute, second;
447 switch (trailing) {
448 case DEGREE:
449 degree = s;
450 break;
451 default: // case MINUTE: case SECOND:
452 string::size_type p = s.find_first_of('.');
453 long long i;
454 if (p == 0)
455 i = 0;
456 else {
457 i = stoll(s);
458 if (p == string::npos)
459 s.clear();
460 else
461 s = s.substr(p);
462 }
463 // Now i in [0,Math::dm] or [0,Math::ds] for MINUTE/DEGREE
464 switch (trailing) {
465 case MINUTE:
466 minute = to_string(i % Math::dm) + s; i /= Math::dm;
467 degree = Utility::str(i + idegree, 0); // no overflow since i in [0,1]
468 break;
469 default: // case SECOND:
470 second = to_string(i % Math::ms) + s; i /= Math::ms;
471 minute = to_string(i % Math::dm) ; i /= Math::dm;
472 degree = Utility::str(i + idegree, 0); // no overflow since i in [0,1]
473 break;
474 }
475 break;
476 }
477 // No glue together degree+minute+second with
478 // sign + zero-fill + delimiters + hemisphere
479 ostringstream str;
480 if (prec) ++prec; // Extra width for decimal point
481 if (ind == NONE && sign < 0)
482 str << '-';
483 str << setfill('0');
484 switch (trailing) {
485 case DEGREE:
486 if (ind != NONE)
487 str << setw(1 + min(int(ind), 2) + prec);
488 str << degree;
489 // Don't include degree designator (d) if it is the trailing component.
490 break;
491 case MINUTE:
492 if (ind != NONE)
493 str << setw(1 + min(int(ind), 2));
494 str << degree << (dmssep ? dmssep : char(tolower(dmsindicators_[0])))
495 << setw(2 + prec) << minute;
496 if (!dmssep)
497 str << char(tolower(dmsindicators_[1]));
498 break;
499 default: // case SECOND:
500 if (ind != NONE)
501 str << setw(1 + min(int(ind), 2));
502 str << degree << (dmssep ? dmssep : char(tolower(dmsindicators_[0])))
503 << setw(2)
504 << minute << (dmssep ? dmssep : char(tolower(dmsindicators_[1])))
505 << setw(2 + prec) << second;
506 if (!dmssep)
507 str << char(tolower(dmsindicators_[2]));
508 break;
509 }
510 if (ind != NONE && ind != AZIMUTH)
511 str << hemispheres_[(ind == LATITUDE ? 0 : 2) + (sign < 0 ? 0 : 1)];
512 return str.str();
513 }
514
515} // namespace GeographicLib
DMS.hpp
Header for GeographicLib::DMS class.
real
GeographicLib::Math::real real
Definition: GeodSolve.cpp:29
Utility.hpp
Header for GeographicLib::Utility class.
GeographicLib::DMS::DecodeAzimuth
static Math::real DecodeAzimuth(const std::string &azistr)
Definition: DMS.cpp:407
GeographicLib::DMS::flag
flag
Definition: DMS.hpp:41
GeographicLib::DMS::LONGITUDE
@ LONGITUDE
Definition: DMS.hpp:56
GeographicLib::DMS::LATITUDE
@ LATITUDE
Definition: DMS.hpp:51
GeographicLib::DMS::AZIMUTH
@ AZIMUTH
Definition: DMS.hpp:62
GeographicLib::DMS::NONE
@ NONE
Definition: DMS.hpp:46
GeographicLib::DMS::DecodeAngle
static Math::real DecodeAngle(const std::string &angstr)
Definition: DMS.cpp:398
GeographicLib::DMS::component
component
Definition: DMS.hpp:73
GeographicLib::DMS::SECOND
@ SECOND
Definition: DMS.hpp:88
GeographicLib::DMS::DEGREE
@ DEGREE
Definition: DMS.hpp:78
GeographicLib::DMS::MINUTE
@ MINUTE
Definition: DMS.hpp:83
GeographicLib::DMS::Encode
static std::string Encode(real angle, component trailing, unsigned prec, flag ind=NONE, char dmssep=char(0))
Definition: DMS.cpp:416
GeographicLib::DMS::DecodeLatLon
static void DecodeLatLon(const std::string &dmsa, const std::string &dmsb, real &lat, real &lon, bool longfirst=false)
Definition: DMS.cpp:368
GeographicLib::DMS::Decode
static Math::real Decode(const std::string &dms, flag &ind)
Definition: DMS.cpp:40
GeographicLib::GeographicErr
Exception handling for GeographicLib.
Definition: Constants.hpp:316
GeographicLib::Math::AngNormalize
static T AngNormalize(T x)
Definition: Math.cpp:71
GeographicLib::Math::real
double real
Definition: Math.hpp:100
GeographicLib::Math::dm
@ dm
minutes per degree
Definition: Math.hpp:139
GeographicLib::Math::td
@ td
degrees per turn
Definition: Math.hpp:142
GeographicLib::Math::ms
@ ms
seconds per minute
Definition: Math.hpp:140
GeographicLib::Math::ds
@ ds
seconds per degree
Definition: Math.hpp:143
GeographicLib::Math::qd
@ qd
degrees per quarter turn
Definition: Math.hpp:138
GeographicLib::Math::extra_digits
static int extra_digits()
Definition: Math.cpp:51
GeographicLib::Utility::lookup
static int lookup(const std::string &s, char c)
Definition: Utility.cpp:160
GeographicLib::Utility::str
static std::string str(T x, int p=-1)
Definition: Utility.hpp:161
GeographicLib
Namespace for GeographicLib.
Definition: Accumulator.cpp:12
std
Definition: NearestNeighbor.hpp:812