geodetic 0.0.1

data/docs/reference/geoid-height.md

@@ -0,0 +1,182 @@
+# Geoid Height Reference
+
+## Geodetic::GeoidHeight
+
+Provides conversion between ellipsoidal heights (height above the reference ellipsoid) and orthometric heights (height above the geoid / mean sea level). Supports multiple geoid models and vertical datums.
+
+### Constructor
+
+```ruby
+geoid = Geodetic::GeoidHeight.new(
+  geoid_model: 'EGM2008',            # default
+  interpolation_method: 'bilinear'    # default
+)
+```
+
+Raises a RuntimeError if the geoid model is not recognized.
+
+### Attributes
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `geoid_model` | String | The active geoid model name |
+| `interpolation_method` | String | Interpolation method for grid lookups |
+
+---
+
+## Geoid Models
+
+| Model | Full Name | Resolution (arc-min) | Accuracy (m) | Epoch | Region |
+|-------|-----------|---------------------|---------------|-------|--------|
+| `EGM96` | Earth Gravitational Model 1996 | 15.0 | 1.0 | 1996 | Global |
+| `EGM2008` | Earth Gravitational Model 2008 | 2.5 | 0.5 | 2008 | Global |
+| `GEOID18` | GEOID18 (CONUS) | 1.0 | 0.1 | 2018 | CONUS |
+| `GEOID12B` | GEOID12B (CONUS) | 1.0 | 0.15 | 2012 | CONUS |
+
+Regional models (GEOID18, GEOID12B) fall back to global models for positions outside their coverage area.
+
+---
+
+## Vertical Datums
+
+| Datum | Full Name | Region | Type | Reference Geoid |
+|-------|-----------|--------|------|-----------------|
+| `NAVD88` | North American Vertical Datum of 1988 | North America | Orthometric | GEOID18 |
+| `NGVD29` | National Geodetic Vertical Datum of 1929 | United States | Orthometric | GEOID12B |
+| `MSL` | Mean Sea Level | Global | Orthometric | EGM2008 |
+| `HAE` | Height Above Ellipsoid | Global | Ellipsoidal | (none) |
+
+---
+
+## Instance Methods
+
+### `geoid_height_at(lat, lng)`
+
+Returns the geoid undulation (separation between ellipsoid and geoid) at the given latitude and longitude, in meters.
+
+```ruby
+geoid = Geodetic::GeoidHeight.new(geoid_model: 'EGM2008')
+height = geoid.geoid_height_at(38.8977, -77.0365)
+```
+
+### `ellipsoidal_to_orthometric(lat, lng, ellipsoidal_height)`
+
+Converts an ellipsoidal height to an orthometric height by subtracting the geoid undulation.
+
+```ruby
+orthometric = geoid.ellipsoidal_to_orthometric(38.8977, -77.0365, 100.0)
+```
+
+### `orthometric_to_ellipsoidal(lat, lng, orthometric_height)`
+
+Converts an orthometric height to an ellipsoidal height by adding the geoid undulation.
+
+```ruby
+ellipsoidal = geoid.orthometric_to_ellipsoidal(38.8977, -77.0365, 65.0)
+```
+
+### `convert_vertical_datum(lat, lng, height, from_datum, to_datum)`
+
+Converts a height value between any two vertical datums. Handles the intermediate conversion through ellipsoidal height when both datums are orthometric.
+
+```ruby
+navd88_height = geoid.convert_vertical_datum(
+  38.8977, -77.0365, 100.0,
+  'HAE',     # from Height Above Ellipsoid
+  'NAVD88'   # to NAVD88 orthometric
+)
+```
+
+### `in_coverage?(lat, lng)`
+
+Returns `true` if the given position falls within the coverage area of the current geoid model. Global models always return `true`. CONUS models check for approximate continental US bounds.
+
+```ruby
+geoid = Geodetic::GeoidHeight.new(geoid_model: 'GEOID18')
+geoid.in_coverage?(40.0, -100.0)  # => true  (within CONUS)
+geoid.in_coverage?(51.5, -0.1)    # => false (London, outside CONUS)
+```
+
+### `accuracy_estimate(lat, lng)`
+
+Returns the estimated accuracy of the geoid model at the given position, in meters. Regional models return their base accuracy within coverage and 3x the base accuracy outside coverage.
+
+```ruby
+geoid.accuracy_estimate(40.0, -100.0)  # => 0.1 (GEOID18 within CONUS)
+geoid.accuracy_estimate(51.5, -0.1)    # => 0.3 (GEOID18 outside CONUS)
+```
+
+### `model_info`
+
+Returns the full information hash for the current geoid model.
+
+```ruby
+geoid.model_info
+# => { name: "Earth Gravitational Model 2008", resolution: 2.5, accuracy: 0.5, epoch: 2008 }
+```
+
+---
+
+## Class Methods
+
+### `GeoidHeight.available_models`
+
+Returns an array of available geoid model names.
+
+```ruby
+Geodetic::GeoidHeight.available_models
+# => ["EGM96", "EGM2008", "GEOID18", "GEOID12B"]
+```
+
+### `GeoidHeight.available_vertical_datums`
+
+Returns an array of available vertical datum names.
+
+```ruby
+Geodetic::GeoidHeight.available_vertical_datums
+# => ["NAVD88", "NGVD29", "MSL", "HAE"]
+```
+
+---
+
+## Geodetic::GeoidHeightSupport (Mixin)
+
+The `GeoidHeightSupport` module is included in `Geodetic::Coordinates::LLA`, adding geoid-related methods directly to LLA instances.
+
+### Mixin Methods
+
+#### `geoid_height(geoid_model = 'EGM2008')`
+
+Returns the geoid undulation at the LLA position.
+
+```ruby
+point = Geodetic::Coordinates::LLA.new(lat: 38.8977, lng: -77.0365, alt: 100.0)
+point.geoid_height              # Uses EGM2008
+point.geoid_height('GEOID18')   # Uses GEOID18
+```
+
+#### `orthometric_height(geoid_model = 'EGM2008')`
+
+Returns the orthometric height (height above geoid) by subtracting the geoid undulation from the LLA altitude.
+
+```ruby
+point.orthometric_height  # alt minus geoid undulation
+```
+
+#### `convert_height_datum(from_datum, to_datum, geoid_model = 'EGM2008')`
+
+Returns a new LLA with the altitude converted between vertical datums. The original object is not modified.
+
+```ruby
+wgs84_point = Geodetic::Coordinates::LLA.new(lat: 40.0, lng: -100.0, alt: 300.0)
+navd88_point = wgs84_point.convert_height_datum('HAE', 'NAVD88')
+```
+
+### Class Extension
+
+The mixin also extends the including class with a `with_geoid_height` class method and a `geoid_model` reader, though these are primarily for internal use:
+
+```ruby
+Geodetic::Coordinates::LLA.with_geoid_height('GEOID18')
+Geodetic::Coordinates::LLA.geoid_model  # => 'GEOID18'
+```

data/docs/reference/serialization.md

@@ -0,0 +1,252 @@
+# Serialization Reference
+
+All coordinate classes provide methods for converting to and from string and array representations. This enables storage, transmission, and reconstruction of coordinate objects.
+
+---
+
+## Common Serialization Methods
+
+Every coordinate class implements these four methods:
+
+| Method | Direction | Description |
+|--------|-----------|-------------|
+| `to_s(precision)` | Export | Returns a comma-separated string with controlled decimal places |
+| `self.from_string(string)` | Import | Parses a comma-separated string into a new instance |
+| `to_a` | Export | Returns an array of component values (full precision) |
+| `self.from_array(array)` | Import | Constructs a new instance from an array |
+
+### Precision Parameter
+
+All `to_s` methods accept an optional `precision` parameter controlling the number of decimal places. Each class has a sensible default:
+
+| Class | Default Precision | Notes |
+|-------|------------------|-------|
+| LLA | 6 | Altitude capped at min(precision, 2) |
+| Bearing | 4 | |
+| All others | 2 | Meters-based coordinates |
+
+Passing `0` returns integer values (no decimal point). MGRS and USNG are string-based and do not accept a precision parameter.
+
+```ruby
+lla = Geodetic::Coordinates::LLA.new(lat: 47.6205, lng: -122.3493, alt: 184.0)
+lla.to_s        # => "47.620500, -122.349300, 184.00"
+lla.to_s(3)     # => "47.620, -122.349, 184.00"
+lla.to_s(0)     # => "48, -122, 184"
+```
+
+---
+
+## Format Reference by Class
+
+### LLA
+
+```ruby
+point = Geodetic::Coordinates::LLA.new(lat: 38.8977, lng: -77.0365, alt: 100.0)
+
+point.to_s    # => "38.897700, -77.036500, 100.00"
+point.to_s(2) # => "38.90, -77.04, 100.00"
+point.to_a    # => [38.8977, -77.0365, 100.0]
+
+Geodetic::Coordinates::LLA.from_string("38.8977, -77.0365, 100.0")
+Geodetic::Coordinates::LLA.from_array([38.8977, -77.0365, 100.0])
+```
+
+**LLA-specific: DMS format**
+
+LLA also supports degrees-minutes-seconds notation:
+
+```ruby
+point.to_dms
+# => "38 53' 51.72\" N, 77 2' 11.40\" W, 100.00 m"
+
+Geodetic::Coordinates::LLA.from_dms("38 53' 51.72\" N, 77 2' 11.40\" W, 100.0 m")
+```
+
+The DMS string format is: `DD MM' SS.ss" H, DDD MM' SS.ss" H, ALT m` where H is N/S for latitude and E/W for longitude. The altitude portion is optional in `from_dms` (defaults to 0.0).
+
+### ECEF
+
+```ruby
+point = Geodetic::Coordinates::ECEF.new(x: 1130730.0, y: -4828583.0, z: 3991570.0)
+
+point.to_s    # => "1130730.00, -4828583.00, 3991570.00"
+point.to_s(0) # => "1130730, -4828583, 3991570"
+point.to_a    # => [1130730.0, -4828583.0, 3991570.0]
+
+Geodetic::Coordinates::ECEF.from_string("1130730.0, -4828583.0, 3991570.0")
+Geodetic::Coordinates::ECEF.from_array([1130730.0, -4828583.0, 3991570.0])
+```
+
+### UTM
+
+```ruby
+point = Geodetic::Coordinates::UTM.new(easting: 323394.0, northing: 4307396.0, altitude: 100.0, zone: 18, hemisphere: 'N')
+
+point.to_s    # => "323394.00, 4307396.00, 100.00, 18, N"
+point.to_a    # => [323394.0, 4307396.0, 100.0, 18, "N"]
+
+Geodetic::Coordinates::UTM.from_string("323394.0, 4307396.0, 100.0, 18, N")
+Geodetic::Coordinates::UTM.from_array([323394.0, 4307396.0, 100.0, 18, "N"])
+```
+
+Note: The array and string formats include all five components: easting, northing, altitude, zone number, and hemisphere.
+
+### ENU
+
+```ruby
+point = Geodetic::Coordinates::ENU.new(e: 100.0, n: 200.0, u: 50.0)
+
+point.to_s    # => "100.00, 200.00, 50.00"
+point.to_a    # => [100.0, 200.0, 50.0]
+
+Geodetic::Coordinates::ENU.from_string("100.0, 200.0, 50.0")
+Geodetic::Coordinates::ENU.from_array([100.0, 200.0, 50.0])
+```
+
+### NED
+
+```ruby
+point = Geodetic::Coordinates::NED.new(n: 200.0, e: 100.0, d: -50.0)
+
+point.to_s    # => "200.00, 100.00, -50.00"
+point.to_a    # => [200.0, 100.0, -50.0]
+
+Geodetic::Coordinates::NED.from_string("200.0, 100.0, -50.0")
+Geodetic::Coordinates::NED.from_array([200.0, 100.0, -50.0])
+```
+
+### WebMercator
+
+```ruby
+point = Geodetic::Coordinates::WebMercator.new(x: -8575605.0, y: 4707175.0)
+
+point.to_s    # => "-8575605.00, 4707175.00"
+point.to_a    # => [-8575605.0, 4707175.0]
+
+Geodetic::Coordinates::WebMercator.from_string("-8575605.0, 4707175.0")
+Geodetic::Coordinates::WebMercator.from_array([-8575605.0, 4707175.0])
+```
+
+### UPS
+
+```ruby
+point = Geodetic::Coordinates::UPS.new(easting: 2000000.0, northing: 2000000.0, hemisphere: 'N', zone: 'Y')
+
+point.to_s    # => "2000000.00, 2000000.00, N, Y"
+point.to_a    # => [2000000.0, 2000000.0, "N", "Y"]
+
+Geodetic::Coordinates::UPS.from_string("2000000.0, 2000000.0, N, Y")
+Geodetic::Coordinates::UPS.from_array([2000000.0, 2000000.0, "N", "Y"])
+```
+
+### BNG
+
+```ruby
+point = Geodetic::Coordinates::BNG.new(easting: 530000.0, northing: 180000.0)
+
+point.to_s    # => "530000.00, 180000.00"
+point.to_a    # => [530000.0, 180000.0]
+
+Geodetic::Coordinates::BNG.from_string("530000.0, 180000.0")
+Geodetic::Coordinates::BNG.from_array([530000.0, 180000.0])
+```
+
+BNG also supports grid reference notation via the constructor:
+
+```ruby
+point = Geodetic::Coordinates::BNG.new(grid_ref: "TQ 30 80")
+point.to_grid_reference(6)  # => "TQ 300000 800000"
+point.to_grid_reference(0)  # => "TQ" (grid square only)
+```
+
+### StatePlane
+
+```ruby
+point = Geodetic::Coordinates::StatePlane.new(easting: 2000000.0, northing: 500000.0, zone_code: 'CA_I')
+
+point.to_s    # => "2000000.00, 500000.00, CA_I"
+point.to_a    # => [2000000.0, 500000.0, "CA_I"]
+
+Geodetic::Coordinates::StatePlane.from_string("2000000.0, 500000.0, CA_I")
+Geodetic::Coordinates::StatePlane.from_array([2000000.0, 500000.0, "CA_I"])
+```
+
+---
+
+## MGRS and USNG (String-Based Formats)
+
+MGRS and USNG use alphanumeric grid references rather than numeric arrays. They support `to_s` and `from_string` but do not provide `to_a` / `from_array`.
+
+### MGRS
+
+```ruby
+mgrs = Geodetic::Coordinates::MGRS.new(mgrs_string: "18SUJ2034706880")
+mgrs.to_s    # => "18SUJ2034706880"
+
+Geodetic::Coordinates::MGRS.from_string("18SUJ2034706880")
+```
+
+The MGRS string format is: `{zone_number}{zone_letter}{square_id}{easting}{northing}` with no spaces. Precision varies based on the number of coordinate digits (0 to 5 pairs).
+
+### USNG
+
+```ruby
+usng = Geodetic::Coordinates::USNG.new(usng_string: "18S UJ 20347 06880")
+usng.to_s    # => "18S UJ 20347 06880"
+
+Geodetic::Coordinates::USNG.from_string("18S UJ 20347 06880")
+```
+
+USNG uses the same underlying format as MGRS but separates components with spaces for readability. Both spaced and non-spaced formats are accepted by `from_string`. USNG also provides:
+
+```ruby
+usng.to_full_format        # => "18S UJ 20347 06880"
+usng.to_abbreviated_format # => "18S UJ 20347 6880"
+```
+
+---
+
+## Roundtrip Examples
+
+String and array serialization support full roundtrip fidelity:
+
+```ruby
+# LLA roundtrip via string
+original = Geodetic::Coordinates::LLA.new(lat: 40.7128, lng: -74.0060, alt: 10.0)
+restored = Geodetic::Coordinates::LLA.from_string(original.to_s)
+original == restored  # => true
+
+# ECEF roundtrip via array
+original = Geodetic::Coordinates::ECEF.new(x: 1334000.0, y: -4654000.0, z: 4138000.0)
+restored = Geodetic::Coordinates::ECEF.from_array(original.to_a)
+original == restored  # => true
+
+# UTM roundtrip via string
+original = Geodetic::Coordinates::UTM.new(easting: 583960.0, northing: 4507523.0, altitude: 10.0, zone: 18, hemisphere: 'N')
+restored = Geodetic::Coordinates::UTM.from_string(original.to_s)
+original == restored  # => true
+
+# LLA roundtrip via DMS
+original = Geodetic::Coordinates::LLA.new(lat: 38.8977, lng: -77.0365, alt: 100.0)
+dms_string = original.to_dms
+restored = Geodetic::Coordinates::LLA.from_dms(dms_string)
+# Note: DMS roundtrip has minor floating-point precision differences
+```
+
+---
+
+## Summary Table
+
+| Class | `to_s` Format | Default Precision | `to_a` Elements | Extra Formats |
+|-------|--------------|-------------------|-----------------|---------------|
+| LLA | `lat, lng, alt` | 6 (alt: 2) | `[lat, lng, alt]` | `to_dms` / `from_dms` |
+| ECEF | `x, y, z` | 2 | `[x, y, z]` | -- |
+| UTM | `easting, northing, alt, zone, hemisphere` | 2 | `[easting, northing, alt, zone, hemisphere]` | -- |
+| ENU | `e, n, u` | 2 | `[e, n, u]` | -- |
+| NED | `n, e, d` | 2 | `[n, e, d]` | -- |
+| WebMercator | `x, y` | 2 | `[x, y]` | -- |
+| UPS | `easting, northing, hemisphere, zone` | 2 | `[easting, northing, hemisphere, zone]` | -- |
+| BNG | `easting, northing` | 2 | `[easting, northing]` | `to_grid_reference` / `grid_ref:` constructor |
+| StatePlane | `easting, northing, zone_code` | 2 | `[easting, northing, zone_code]` | -- |
+| MGRS | `grid_zone+square+coords` | n/a | (not available) | String-based only |
+| USNG | `grid_zone square coords` | n/a | (not available) | `to_full_format`, `to_abbreviated_format` |

data/examples/01_basic_conversions.rb

@@ -0,0 +1,187 @@
+#!/usr/bin/env ruby
+
+# Demonstration of orthogonal coordinate system conversions
+# Shows all coordinate systems converting to/from each other
+
+require_relative '../lib/geodetic'
+require_relative '../lib/geodetic/coordinates/lla'
+require_relative '../lib/geodetic/coordinates/ecef'
+require_relative '../lib/geodetic/coordinates/enu'
+require_relative '../lib/geodetic/coordinates/ned'
+require_relative '../lib/geodetic/coordinates/utm'
+
+include Geodetic
+LLA  = Coordinates::LLA
+ECEF = Coordinates::ECEF
+ENU  = Coordinates::ENU
+NED  = Coordinates::NED
+UTM  = Coordinates::UTM
+
+puts "=== Orthogonal Coordinate System Conversions Demo ==="
+puts
+
+# Test location: Seattle Space Needle
+seattle_lat = 47.6205
+seattle_lng = -122.3493
+seattle_alt = 184.0
+
+puts "Original Test Point (Seattle Space Needle):"
+puts "Latitude:  #{seattle_lat}"
+puts "Longitude: #{seattle_lng}"
+puts "Altitude:  #{seattle_alt}m"
+puts
+
+# Create initial LLA coordinate
+lla = LLA.new(lat: seattle_lat, lng: seattle_lng, alt: seattle_alt)
+puts "1. LLA Coordinate: #{lla}"
+
+# LLA -> ECEF
+ecef = lla.to_ecef
+puts "2. LLA -> ECEF: #{ecef}"
+
+# ECEF -> LLA (roundtrip test)
+lla_back = ecef.to_lla
+puts "3. ECEF -> LLA: #{lla_back}"
+lat_error = (seattle_lat - lla_back.lat).abs
+lng_error = (seattle_lng - lla_back.lng).abs
+alt_error = (seattle_alt - lla_back.alt).abs
+puts "   Roundtrip errors: lat=#{lat_error}, lng=#{lng_error}, alt=#{alt_error}"
+puts
+
+# LLA -> UTM
+utm = lla.to_utm
+puts "4. LLA -> UTM: #{utm}"
+
+# UTM -> LLA (roundtrip test)
+lla_from_utm = utm.to_lla
+puts "5. UTM -> LLA: #{lla_from_utm}"
+puts
+
+# Reference point for local coordinates (slightly offset)
+ref_lla = LLA.new(lat: seattle_lat - 0.01, lng: seattle_lng + 0.01, alt: seattle_alt - 100)
+puts "Reference point for local coordinates:"
+puts "6. Reference LLA: #{ref_lla}"
+
+# LLA -> ENU
+enu = lla.to_enu(ref_lla)
+puts "7. LLA -> ENU: #{enu}"
+puts "   (East: #{enu.e.round(2)}m, North: #{enu.n.round(2)}m, Up: #{enu.u.round(2)}m)"
+
+# ENU -> LLA (roundtrip test)
+lla_from_enu = enu.to_lla(ref_lla)
+puts "8. ENU -> LLA: #{lla_from_enu}"
+
+# LLA -> NED
+ned = lla.to_ned(ref_lla)
+puts "9. LLA -> NED: #{ned}"
+puts "   (North: #{ned.n.round(2)}m, East: #{ned.e.round(2)}m, Down: #{ned.d.round(2)}m)"
+
+# NED -> LLA (roundtrip test)
+lla_from_ned = ned.to_lla(ref_lla)
+puts "10. NED -> LLA: #{lla_from_ned}"
+puts
+
+# Cross-conversions between local coordinate systems
+puts "=== Local Coordinate Cross-Conversions ==="
+
+# ENU <-> NED
+ned_from_enu = enu.to_ned
+puts "11. ENU -> NED: #{ned_from_enu}"
+enu_from_ned = ned.to_enu
+puts "12. NED -> ENU: #{enu_from_ned}"
+
+# Verify ENU <-> NED consistency
+enu_error_e = (enu.e - enu_from_ned.e).abs
+enu_error_n = (enu.n - enu_from_ned.n).abs
+enu_error_u = (enu.u - enu_from_ned.u).abs
+puts "    ENU roundtrip errors: e=#{enu_error_e}, n=#{enu_error_n}, u=#{enu_error_u}"
+puts
+
+# Chain conversions to test system consistency
+puts "=== Chain Conversion Test (LLA -> ECEF -> ENU -> NED -> ECEF -> LLA) ==="
+
+ref_ecef = ref_lla.to_ecef
+
+step1_ecef = lla.to_ecef
+puts "13. LLA -> ECEF: #{step1_ecef}"
+
+step2_enu = step1_ecef.to_enu(ref_ecef, ref_lla)
+puts "14. ECEF -> ENU: #{step2_enu}"
+
+step3_ned = step2_enu.to_ned
+puts "15. ENU -> NED: #{step3_ned}"
+
+step4_ecef = step3_ned.to_ecef(ref_ecef, ref_lla)
+puts "16. NED -> ECEF: #{step4_ecef}"
+
+step5_lla = step4_ecef.to_lla
+puts "17. ECEF -> LLA: #{step5_lla}"
+
+# Check final accuracy
+final_lat_error = (seattle_lat - step5_lla.lat).abs
+final_lng_error = (seattle_lng - step5_lla.lng).abs
+final_alt_error = (seattle_alt - step5_lla.alt).abs
+puts "    Chain conversion errors: lat=#{final_lat_error}, lng=#{final_lng_error}, alt=#{final_alt_error}"
+puts
+
+# Distance calculations
+puts "=== Distance and Bearing Calculations ==="
+
+# Create another test point (Pioneer Square, Seattle)
+pioneer_lla = LLA.new(lat: 47.6097, lng: -122.3331, alt: 56.0)
+puts "18. Second point (Pioneer Square): #{pioneer_lla}"
+
+# ECEF distance
+pioneer_ecef = pioneer_lla.to_ecef
+ecef_distance = ecef.distance_to(pioneer_ecef)
+puts "19. ECEF distance: #{ecef_distance.to_s}"
+
+# ENU distance and bearing
+pioneer_enu = pioneer_lla.to_enu(lla)  # Using first point as reference
+enu_origin = ENU.new(e: 0, n: 0, u: 0)
+enu_distance = enu_origin.distance_to_origin
+enu_bearing = enu_origin.local_bearing_to(pioneer_enu)
+horizontal_distance = enu_origin.horizontal_distance_to(pioneer_enu)
+
+puts "20. ENU distance to origin: #{enu_distance.round(2)}m"
+puts "21. ENU bearing: #{enu_bearing.round(1)} degrees"
+puts "22. Horizontal distance: #{horizontal_distance.round(2)}m"
+
+# UTM distance (same zone)
+pioneer_utm = pioneer_lla.to_utm
+utm_distance = utm.distance_to(pioneer_utm)
+puts "23. UTM distance: #{utm_distance.to_s}"
+
+puts
+puts "=== All Coordinate Systems Summary ==="
+puts "LLA:  #{lla}"
+puts "ECEF: #{ecef}"
+puts "UTM:  #{utm}"
+puts "ENU:  #{enu} (relative to reference)"
+puts "NED:  #{ned} (relative to reference)"
+
+puts
+puts "=== to_s Precision Control ==="
+puts
+puts "All to_s methods accept an optional precision parameter:"
+puts
+puts "LLA (default=6):"
+puts "  to_s     => #{lla.to_s}"
+puts "  to_s(3)  => #{lla.to_s(3)}"
+puts "  to_s(0)  => #{lla.to_s(0)}"
+puts
+puts "ECEF (default=2):"
+puts "  to_s     => #{ecef.to_s}"
+puts "  to_s(0)  => #{ecef.to_s(0)}"
+puts
+puts "UTM (default=2):"
+puts "  to_s     => #{utm.to_s}"
+puts "  to_s(0)  => #{utm.to_s(0)}"
+puts
+puts "ENU (default=2):"
+puts "  to_s     => #{enu.to_s}"
+puts "  to_s(4)  => #{enu.to_s(4)}"
+puts "  to_s(0)  => #{enu.to_s(0)}"
+puts
+puts "All coordinate systems successfully demonstrate complete orthogonal conversions!"
+puts "Each system can convert to and from every other system with high precision."