Decimal Degrees vs DMS (and DDM)

DD ↔ DMS conversion is the single most common path between coordinate formats. Surveying records, paper topographic maps, and many older datasets are in DMS; software, modern databases, and most APIs are in DD. Anyone integrating data from both ends needs to convert. DDM (degrees-decimal-minutes) is a third format that splits the difference, used in marine and aviation work — less common than DD or DMS but appearing widely enough in flight plans and marine GPS displays that it deserves a place in any conversion routine.

The pillar /learn/coordinate-formats-explained covers all three plus the grid-based formats (UTM, MGRS, Plus Codes). This article zooms in on the angular three: the conversion math, the precision trade-offs, and the off-by-one bugs that show up when sign handling or floating-point rounding goes wrong.

What each format encodes

Decimal degrees (DD) stores a coordinate as a single signed decimal number. Latitude ranges from -90 to +90; longitude from -180 to +180. The sign of the number encodes the hemisphere: positive latitude is north, negative is south; positive longitude is east, negative is west. Storage: one number per axis. Example: 40.7484, -73.9857 (Empire State Building).

Degrees, minutes, seconds (DMS) splits the same value into three components: integer degrees, integer arcminutes (0–59), and decimal arcseconds (0 to less than 60). The hemisphere is encoded as a letter suffix (N, S, E, W) or as a sign on the degrees. Example: 40°44'54.24"N, 73°59'08.52"W.

Degrees, decimal minutes (DDM) keeps integer degrees but expresses the fractional part as decimal arcminutes (0 to less than 60.000…). Two numerical components per axis plus a hemisphere letter or sign. Example: 40°44.904'N, 73°59.142'W.

All three formats encode the same physical angle. ISO 6709 lists all three as allowed representations. The choice between them is a convention question (which domain you're publishing in), not an accuracy question.

The conversion math

The formulas are straightforward arithmetic. All operate on the absolute value of the coordinate; the sign or hemisphere is tracked separately and reattached at the end.

DD → DMS

1.  abs        = |dd|
2.  degrees    = floor(abs)
3.  fractional = abs - degrees
4.  minutes    = floor(fractional × 60)
5.  seconds    = (fractional × 60 - minutes) × 60
                = (abs - degrees - minutes/60) × 3600

Reattach sign: if the original DD was negative, the result is in the S or W hemisphere (depending on whether the value is latitude or longitude).

DMS → DD

dd = (degrees + minutes/60 + seconds/3600) × sign

The sign is +1 for N or E, -1 for S or W.

DD → DDM

1.  abs           = |dd|
2.  degrees       = floor(abs)
3.  decimal_min   = (abs - degrees) × 60

DDM → DD

dd = (degrees + decimal_min/60) × sign

DMS ↔ DDM

The two share the integer-degree component. Converting between them operates on the minutes:

DMS → DDM:   decimal_min = minutes + seconds/60
DDM → DMS:   minutes_int = floor(decimal_min)
             seconds     = (decimal_min - minutes_int) × 60

A worked example: Empire State Building

Convert 40.7484 (latitude of the Empire State Building) to DMS:

abs        = 40.7484
degrees    = floor(40.7484)      = 40
fractional = 40.7484 - 40        = 0.7484
minutes    = floor(0.7484 × 60)  = floor(44.904) = 44
seconds    = (0.7484 × 60 - 44) × 60
           = (44.904 - 44) × 60
           = 0.904 × 60
           = 54.24

Original is positive (northern hemisphere) → result is 40°44'54.24"N.

Convert 40.7484 to DDM:

degrees     = 40
decimal_min = (40.7484 - 40) × 60 = 0.7484 × 60 = 44.904

Result: 40°44.904'N.

Convert -73.9857 (longitude of the Empire State Building) to DMS:

abs        = 73.9857
degrees    = 73
fractional = 0.9857
minutes    = floor(0.9857 × 60) = floor(59.142) = 59
seconds    = (59.142 - 59) × 60 = 0.142 × 60 = 8.52

Original is negative → western hemisphere → 73°59'08.52"W.

The live DMS ↔ Decimal Degrees converter implements this arithmetic and is convenient for sanity-checking by hand.

Round-trip verification

A useful sanity check on any conversion routine: feed the output back through the inverse and confirm you recover the input. For 40°44'54.24"N:

dd = (40 + 44/60 + 54.24/3600) × (+1)
   = 40 + 0.7333333… + 0.015066…
   = 40.74840

Recovered to five decimals — matched. Run the same check for the longitude:

dd = (73 + 59/60 + 8.52/3600) × (-1)
   = -(73 + 0.9833333… + 0.002366…)
   = -73.98570

Matched. Any routine that doesn't round-trip a known coordinate back to itself within the precision of the arcsecond decimals has a bug — most commonly in the carry arithmetic, the sign attachment, or the order-of-operations in the inverse.

Precision trade-offs

Conversion between DD, DMS, and DDM is mathematically lossless within the limits of the digit precision recorded at each step. At equivalent precision (matched to ~5 m of accuracy, typical of smartphone GPS):

| Precision | DD | DMS | DDM | Ground (equator) | | ----------- | ---------------- | ---------------- | ---------------- | ---------------- | | Continental | 2 dp | 1 arcmin | 1 arcmin | ~1.1 km | | City | 3 dp | 4 seconds | 0.1 arcmin | ~111 m | | Block | 4 dp | 0.4 seconds | 0.01 arcmin | ~11 m | | Doorway | 5 dp | 0.04 seconds | 0.001 arcmin | ~1.1 m | | Fence post | 6 dp | 0.004 seconds | 0.0001 arcmin | ~11 cm |

The trade-offs:

• DD packs precision into trailing decimals. Easy to compare two values numerically; easy to sort and store.
• DMS distributes precision across the arcsecond decimals. A practiced reader can estimate precision from the number of arcsecond decimals — 0.1 second resolution is “a few metres” natively.
• DDM uses fewer numbers per axis but each minute decimal is a coarser unit than an arcsecond. Aviation precision (~10 m) naturally expresses as 0.01 arcminutes, matching one fewer decimal than DD.

For human-shared coordinates from smartphone GPS, 5 decimals of DD = 1 arcsecond resolution in DMS = 0.01 arcminute in DDM is the natural match. Anything finer is false precision — see /learn/precision-vs-accuracy-in-coordinates (when shipped) for the full treatment.

When to use each

The conversion math is just arithmetic; the question of which format to use is a domain question. Briefly:

• DD is the right default for software, databases, APIs, and any program-to-program path. Every modern stack supports it natively.
• DMS is the convention on paper topographic maps (USGS quad sheets, OS Explorer maps), in surveying records, and in scientific contexts that historically used base-60.
• DDM is the convention in marine and aviation work. FAA flight plans, marine GPS displays configured for nautical use, and most maritime publications use DDM.

Pick the format your downstream consumer expects. Store internally in DD; convert at the display layer. The How to Write Coordinates guide covers the practical choice in more detail.

A concrete example of the store-DD, display-flexibly pattern: a database table for surveyed monuments holds lat NUMERIC(9,6) and lon NUMERIC(9,6) columns. A query that returns the nearest five monuments to a search point can run a Vincenty or great-circle distance directly on the numeric columns. The UI layer formats each result in whichever notation the user prefers — DD for software- facing exports, DMS for a downloadable PDF report, DDM for an aviation overlay. The conversion is a cheap arithmetic step at the last moment, never an attribute of the stored data.

Common conversion mistakes

Forgetting to multiply the fractional part by 60. A misread of “0.7484 degrees” as “0.7484 minutes” produces the wrong arcminute value. The fractional part of DD is in degrees; multiply by 60 to get arcminutes.

Sign or hemisphere lost in conversion. The arithmetic operates on the absolute value. If your code computes the components without preserving the sign or attaching the hemisphere letter, you produce ambiguous output. -73.9857 → 73°59'08.52" is incomplete; the correct output is 73°59'08.52"W.

Rounding to 60 seconds (which is not a valid value). Computing arithmetic that yields 59.9998 seconds, then formatting with toFixed(2) produces 60.00 seconds — invalid. The conversion has to carry: 60.00 seconds becomes 0 seconds plus 1 arcminute. If arcminutes were already at 59, the carry propagates: 0 minutes + 1 degree. Defensive code checks the carry chain on every formatting step. The minimal pseudocode is three guarded checks after rounding: if seconds round to 60, set seconds to 0 and add 1 to minutes; if minutes then equal 60, set minutes to 0 and add 1 to degrees. The degree value itself never carries — a coordinate of 89°59'59.99"N near the pole stays at 89 degrees; the next conceptual increment is a hemisphere flip, not a 90th degree of latitude.

False precision after conversion. Round-tripping DD → DMS → DD with arbitrary precision is mathematically lossless. Round-tripping through a less-precise intermediate (e.g., DD-6-decimals → DMS-with- integer-seconds → DD) loses information at the integer-seconds step. Match the precision of every intermediate to the precision you want at the end.

Reading “44.904 minutes” as “44 minutes 904 seconds.” A first-time DDM reader sometimes parses the decimal as seconds. The decimal-point inside the minutes field is the DDM signature; the value is 44 + 0.904 arcminutes, which equals 44 arcminutes plus 54.24 arcseconds, not 44 minutes plus 904 seconds.

Mixing DDM and DMS. Producing 40°44.904'54.24"N — a decimal arcminute followed by arcseconds — is malformed. The output is either DMS (40°44'54.24"N) or DDM (40°44.904'N), not both at once.

Common misconceptions

Conversion is not lossy. If you carry enough precision through each step, DD → DMS → DD returns the original DD value to within double-precision floating-point limits (about 1 part in 10^15). The three formats are mathematically equivalent representations of the same angular value.

More numbers in DMS does not mean more precision. DMS-with-2- decimal-arcseconds has comparable precision to DD-with-6-decimal- places — both resolve to about 30 cm at the equator. The number of components affects readability and writing convention, not accuracy.

DDM and DMS look similar but are not the same. 40°44.904'N is DDM (the .904 is part of the minutes value). 40°44'54.24"N is DMS (the .24 is part of the arcseconds value). The presence of a decimal point inside the minutes value tells you it's DDM; the presence of a separate arcseconds component tells you it's DMS.

Negative arcseconds (or arcminutes) don't exist. All sub-unit components of DMS and DDM are non-negative. The sign or hemisphere indicator applies to the whole result, not to each component. -40°-44'-54.24" is malformed; -40.7484° or 40°44'54.24"S is correct.

The base-60 arithmetic is not specific to coordinates. Time-of- day uses the same convention (60 seconds per minute, 60 minutes per hour). The Babylonian sexagesimal system has historical reach in both timekeeping and astronomical-coordinate work; DMS is the same arithmetic applied to angles instead of to time.

Storing coordinates in DMS strings is a mistake. A DMS string is data-plus-formatting; a DD numeric pair is just data. Storing DD as two numeric columns makes range queries, distance computation, and geographic indexing straightforward. Convert to DMS only at display time. The Coordinately codebase stores all coordinates as DD numerics internally; the DMS ↔ decimal converter handles the boundary at the human-facing edge.