geodetic 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 782ba82d99727dfa9a075fcdfb9dea89f631ebc78e0e105293745c64f77f9dae
-  data.tar.gz: 59e9c844470d77026a9929c8b9ffd01a5d065fd491d8efb67106b0903267c681
+  metadata.gz: 6d81eb7c69d9aff7d512562f54e2413c91c8ff10b2361c9143a8afd0c1af0ca0
+  data.tar.gz: e7fb09dd1f7d4d97f57ea48f9cacb0e6afbd30abedab1aa04cbf1153c2fe4373
 SHA512:
-  metadata.gz: 38543deb9e8d62aa20b4a90c9602b0e97806d7d2f55dd9d308a138b9aea2b033e6f51656a9d247ce750d5abcd5298f170825a3f0e4f013a63198bc467e1f3d8c
-  data.tar.gz: fcb62fac876d350bd784d08bb17d45b7c14218a31ff6cfcce4be7e384e3f9a6a2c711ae3731b4a4241e5b34c062a8ddcdc2fb8ce6786ac114ff35d872ad8a7f3
+  metadata.gz: 90a2e1b8bbc1c6bdf59c7e326d4965f8ec85a16682bccba948fd1f104d7818a5fa34ee179fa00de0221cbfd0e9d9afbd5c667aac46c1a6c9c070b338618b461a
+  data.tar.gz: 85b40d6e961ec4782a9748232eed4191df1dd8a5f22df77afe68c63d64b6b23df0e8ff5ec4ae927038d60919a7825e09c2429bbd4aa8d4447b1737ff81aa4dfd

data/CHANGELOG.md

@@ -15,12 +15,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- **2 new coordinate systems** bringing the total from 15 to 17:
+- **3 new coordinate systems** bringing the total from 15 to 18:
   - `Geodetic::Coordinate::GEOREF` — World Geographic Reference System (aviation/military geocode with variable precision from 15-degree tiles to 0.001-minute resolution)
   - `Geodetic::Coordinate::GARS` — Global Area Reference System (NGA standard with 30-minute cells, 15-minute quadrants, and 5-minute keypads)
-- Full cross-system conversions for GEOREF and GARS — all 17 coordinate systems convert to/from every other system (289 conversion paths)
-- Spatial hash features for GEOREF and GARS: `neighbors`, `to_area`, `precision_in_meters`, `to_slug`, configurable precision
-- Documentation pages: `docs/coordinate-systems/georef.md` and `docs/coordinate-systems/gars.md`
+  - `Geodetic::Coordinate::H3` — Uber's H3 Hexagonal Hierarchical Index (16 resolution levels, hexagonal cells via `libh3` C library through `fiddle`)
+- Full cross-system conversions for GEOREF, GARS, and H3 — all 18 coordinate systems convert to/from every other system (324 conversion paths)
+- Spatial hash features for GEOREF, GARS, and H3: `neighbors`, `to_area`, `precision_in_meters`, `to_slug`, configurable precision
+- H3-specific features: `grid_disk(k)`, `parent(res)`, `children(res)`, `pentagon?`, `cell_area`, `h3_index`, `resolution` (0-15)
+- H3 `to_area` returns `Areas::Polygon` (6 vertices for hexagons, 5 for pentagons) instead of `Areas::Rectangle`
+- H3 `neighbors` returns Array of 6 cells instead of directional Hash with 8 cardinal keys
+- Graceful degradation: H3 raises clear error with installation instructions if `libh3` is not found; all other coordinate systems work normally
+- Documentation pages: `docs/coordinate-systems/georef.md`, `docs/coordinate-systems/gars.md`, and `docs/coordinate-systems/h3.md`
 
 ### Changed
 

data/README.md

@@ -13,7 +13,7 @@
 <td width="50%" valign="top">
 <strong>Key Features</strong><br>
 
-- <strong>17 Coordinate Systems</strong> - LLA, ECEF, UTM, ENU, NED, MGRS, USNG, Web Mercator, UPS, State Plane, BNG, GH36, GH, HAM, OLC, GEOREF, GARS<br>
+- <strong>18 Coordinate Systems</strong> - LLA, ECEF, UTM, ENU, NED, MGRS, USNG, Web Mercator, UPS, State Plane, BNG, GH36, GH, HAM, OLC, GEOREF, GARS, H3<br>
 - <strong>Full Bidirectional Conversions</strong> - Every system converts to and from every other system<br>
 - <strong>Distance Calculations</strong> - Vincenty great-circle and straight-line with unit tracking<br>
 - <strong>Bearing Calculations</strong> - Forward azimuth, back azimuth, compass directions, elevation angles<br>
@@ -27,7 +27,7 @@
 </tr>
 </table>
 
-<p>Geodetic enables precise conversion between geodetic coordinate systems in Ruby. All 17 coordinate systems support complete bidirectional conversions with high precision. Review the <a href="https://madbomber.github.io/geodetic/">full documentation website</a> and explore the <a href="examples/">runnable examples</a>.</p>
+<p>Geodetic enables precise conversion between geodetic coordinate systems in Ruby. All 18 coordinate systems support complete bidirectional conversions with high precision. Review the <a href="https://madbomber.github.io/geodetic/">full documentation website</a> and explore the <a href="examples/">runnable examples</a>.</p>
 
 ## Installation
 
@@ -43,6 +43,20 @@ Or install directly:
 gem install geodetic
 ```
 
+### Optional: H3 Hexagonal Index
+
+The H3 coordinate system requires Uber's [H3 C library](https://h3geo.org/) installed on your system. Without it, all other 17 coordinate systems work normally; H3 operations will raise a helpful error.
+
+```bash
+# macOS
+brew install h3
+
+# Linux (build from source)
+# See https://h3geo.org/docs/installation
+```
+
+You can also set the `LIBH3_PATH` environment variable to point to a custom `libh3` location.
+
 ## Usage
 
 ### Basic Coordinate Creation
@@ -542,7 +556,7 @@ The [`examples/`](examples/) directory contains runnable demo scripts showing pr
 | Script | Description |
 |--------|-------------|
 | [`01_basic_conversions.rb`](examples/01_basic_conversions.rb) | LLA, ECEF, UTM, ENU, NED conversions and roundtrips |
-| [`02_all_coordinate_systems.rb`](examples/02_all_coordinate_systems.rb) | All 17 coordinate systems, cross-system chains, and areas |
+| [`02_all_coordinate_systems.rb`](examples/02_all_coordinate_systems.rb) | All 18 coordinate systems, cross-system chains, and areas |
 | [`03_distance_calculations.rb`](examples/03_distance_calculations.rb) | Distance class features, unit conversions, and arithmetic |
 | [`04_bearing_calculations.rb`](examples/04_bearing_calculations.rb) | Bearing class, compass directions, elevation angles, and chain bearings |
 

data/docs/coordinate-systems/h3.md

@@ -0,0 +1,312 @@
+# Geodetic::Coordinate::H3
+
+## H3 Hexagonal Hierarchical Index
+
+H3 is Uber's hierarchical geospatial indexing system that divides the globe into hexagonal cells (and 12 pentagons per resolution level) using an icosahedron projection. Each cell is identified by a 64-bit integer, typically displayed as a 15-character hex string like `872a1072bffffff`.
+
+**H3 requires the `libh3` C library** installed on your system. Without it, all other coordinate systems work normally; H3 operations raise a clear error message with installation instructions.
+
+### Prerequisites
+
+```bash
+# macOS (Homebrew)
+brew install h3
+
+# Linux (build from source)
+git clone https://github.com/uber/h3.git
+cd h3
+cmake -B build -DCMAKE_INSTALL_PREFIX=/usr/local
+cmake --build build
+sudo cmake --install build
+```
+
+You can also set the `LIBH3_PATH` environment variable to specify a custom library path:
+
+```bash
+export LIBH3_PATH=/path/to/libh3.dylib
+```
+
+Geodetic searches these paths automatically:
+- `/opt/homebrew/lib/libh3.dylib` (macOS ARM Homebrew)
+- `/usr/local/lib/libh3.dylib` (macOS Intel Homebrew)
+- `/usr/lib/libh3.so` (Linux system)
+- `/usr/local/lib/libh3.so` (Linux local install)
+
+### Key Differences from Other Spatial Hashes
+
+| Feature | GH/OLC/GARS/GEOREF/HAM | H3 |
+|---------|------------------------|-----|
+| Cell shape | Rectangle | Hexagon (6 vertices) |
+| `to_area` returns | `Areas::Rectangle` | `Areas::Polygon` |
+| `neighbors` returns | Hash with 8 cardinal keys | Array of 6 cells |
+| Code format | String | 64-bit integer (hex string) |
+| Dependency | None (pure Ruby) | `libh3` (C library via fiddle) |
+
+H3 is a **2D coordinate system** (no altitude). Conversions to/from other systems go through LLA as the intermediary. Each hex string represents a hexagonal cell; the coordinate's point value is the cell's centroid.
+
+## Constructor
+
+```ruby
+# From a hex string
+coord = Geodetic::Coordinate::H3.new("872a1072bffffff")
+
+# From a hex string with 0x prefix
+coord = Geodetic::Coordinate::H3.new("0x872a1072bffffff")
+
+# From a 64-bit integer
+coord = Geodetic::Coordinate::H3.new(0x872a1072bffffff)
+
+# From any coordinate (converts via LLA)
+coord = Geodetic::Coordinate::H3.new(lla_coord)
+coord = Geodetic::Coordinate::H3.new(utm_coord, precision: 9)
+```
+
+| Parameter   | Type                    | Default | Description                                |
+|-------------|-------------------------|---------|--------------------------------------------|
+| `source`    | String, Integer, or Coord | --    | An H3 hex string, integer, or coordinate   |
+| `precision` | Integer                 | 7       | H3 resolution level (0-15)                 |
+
+Raises `ArgumentError` if the source string is empty, contains invalid hex characters, or does not represent a valid H3 cell index. String input is case-insensitive (normalized to lowercase). The `0x` prefix is stripped automatically.
+
+## Attributes
+
+| Attribute  | Type    | Access    | Description                     |
+|------------|---------|-----------|----------------------------------|
+| `code`     | String  | read-only | The hex string representation    |
+| `h3_index` | Integer | read-only | The 64-bit H3 cell index         |
+
+H3 is **immutable** -- there are no setter methods.
+
+## Resolution
+
+H3 uses "resolution" (0-15) instead of string-length precision. Higher resolution means smaller cells.
+
+| Resolution | Approximate Cell Area | Approximate Edge Length |
+|------------|----------------------|------------------------|
+| 0          | 4,357,449 km^2       | 1,108 km               |
+| 1          | 609,788 km^2         | 419 km                 |
+| 2          | 86,801 km^2          | 158 km                 |
+| 3          | 12,393 km^2          | 60 km                  |
+| 4          | 1,770 km^2           | 23 km                  |
+| 5          | 252 km^2             | 8.5 km                 |
+| 6          | 36 km^2              | 3.2 km                 |
+| 7          | 5.2 km^2 (default)   | 1.2 km                 |
+| 8          | 0.74 km^2            | 461 m                  |
+| 9          | 0.105 km^2           | 174 m                  |
+| 10         | 0.015 km^2           | 66 m                   |
+| 11         | 0.002 km^2           | 25 m                   |
+| 12         | 307 m^2              | 9.4 m                  |
+| 13         | 43 m^2               | 3.6 m                  |
+| 14         | 6.2 m^2              | 1.3 m                  |
+| 15         | 0.9 m^2              | 0.5 m                  |
+
+```ruby
+coord.resolution             # => 7 (alias: coord.precision)
+coord.cell_area              # => 5182586.98 (square meters)
+coord.precision_in_meters    # => { lat: ~2276, lng: ~2276, area_m2: ~5182586 }
+```
+
+## Checking Availability
+
+```ruby
+Geodetic::Coordinate::H3.available?   # => true if libh3 is found
+```
+
+## Conversions
+
+All conversions chain through LLA. The datum parameter defaults to `Geodetic::WGS84`.
+
+### Instance Methods
+
+```ruby
+coord.to_lla                    # => LLA (centroid of the cell)
+coord.to_ecef
+coord.to_utm
+coord.to_enu(reference_lla)
+coord.to_ned(reference_lla)
+coord.to_mgrs
+coord.to_usng
+coord.to_web_mercator
+coord.to_ups
+coord.to_state_plane(zone_code)
+coord.to_bng
+coord.to_gh36
+coord.to_gh
+coord.to_ham
+coord.to_olc
+coord.to_georef
+coord.to_gars
+```
+
+### Class Methods
+
+```ruby
+H3.from_lla(lla_coord)
+H3.from_ecef(ecef_coord)
+H3.from_utm(utm_coord)
+H3.from_web_mercator(wm_coord)
+H3.from_gh(gh_coord)
+H3.from_georef(georef_coord)
+H3.from_gars(gars_coord)
+# ... and all other coordinate systems
+```
+
+### LLA Convenience Methods
+
+```ruby
+lla = Geodetic::Coordinate::LLA.new(lat: 40.689167, lng: -74.044444)
+h3 = lla.to_h3                    # default resolution 7
+h3 = lla.to_h3(precision: 9)      # resolution 9
+
+lla = Geodetic::Coordinate::LLA.from_h3(h3)
+```
+
+## Serialization
+
+### `to_s(format = nil)`
+
+Returns the hex string. Pass `:integer` to get the 64-bit integer value.
+
+```ruby
+coord = H3.new("872a1072bffffff")
+coord.to_s             # => "872a1072bffffff"
+coord.to_s(:integer)   # => 608693941536498687
+coord.h3_index         # => 608693941536498687
+```
+
+### `to_slug`
+
+Alias for `to_s`. H3 hex strings are already URL-safe.
+
+### `to_a`
+
+Returns `[lat, lng]` of the cell centroid.
+
+```ruby
+coord.to_a    # => [40.685..., -74.030...]
+```
+
+### `from_string` / `from_array`
+
+```ruby
+H3.from_string("872a1072bffffff")           # from hex string
+H3.from_array([40.689167, -74.044444])       # from [lat, lng]
+```
+
+## Neighbors
+
+Returns all adjacent cells as an Array of H3 instances. Hexagons have 6 neighbors; pentagons have 5.
+
+Note: unlike the rectangular spatial hashes which return a directional Hash (`:N`, `:S`, etc.), H3 returns a flat Array because hexagonal cells do not have cardinal directions.
+
+```ruby
+coord = H3.new("872a1072bffffff")
+neighbors = coord.neighbors
+# => [H3, H3, H3, H3, H3, H3]
+
+neighbors.length    # => 6
+```
+
+## Grid Disk
+
+The `grid_disk(k)` method returns all cells within `k` steps. This is a generalization of `neighbors` (which is `grid_disk(1)` minus self).
+
+```ruby
+coord.grid_disk(0)     # => [self] (1 cell)
+coord.grid_disk(1)     # => [self + 6 neighbors] (7 cells)
+coord.grid_disk(2)     # => 19 cells
+```
+
+## Parent and Children
+
+Navigate the H3 hierarchy by moving to coarser or finer resolution levels.
+
+```ruby
+coord = H3.new("872a1072bffffff")    # resolution 7
+parent = coord.parent(5)              # => H3 at resolution 5
+parent.resolution                     # => 5
+
+children = coord.children(8)          # => Array of 7 H3 cells at resolution 8
+children.length                       # => 7
+children.first.resolution             # => 8
+```
+
+`parent` raises `ArgumentError` if the target resolution is not coarser (lower number). `children` raises `ArgumentError` if the target resolution is not finer (higher number).
+
+## Area
+
+The `to_area` method returns the hexagonal cell boundary as an `Areas::Polygon` with 6 vertices (5 for pentagons).
+
+```ruby
+area = coord.to_area
+# => Geodetic::Areas::Polygon
+
+area.includes?(coord.to_lla)    # => true (centroid is inside the cell)
+area.boundary.length             # => 7 (6 vertices + closing point)
+```
+
+## Pentagon Detection
+
+12 cells at each resolution level are pentagons (artifacts of the icosahedral projection). These have 5 neighbors and 5 boundary vertices instead of 6.
+
+```ruby
+coord.pentagon?    # => false (most cells are hexagons)
+```
+
+## Cell Area
+
+```ruby
+coord.cell_area    # => 5182586.98 (square meters)
+```
+
+## Equality
+
+Two H3 instances are equal if their hex strings match exactly.
+
+```ruby
+H3.new("872a1072bffffff") == H3.new("872a1072bffffff")       # => true
+H3.new("872a1072bffffff") == H3.new(0x872a1072bffffff)       # => true (integer)
+H3.new("872a1072bffffff") == H3.new("87195da49ffffff")       # => false
+```
+
+## `valid?`
+
+Returns `true` if the H3 cell index is valid according to the H3 library.
+
+```ruby
+coord.valid?    # => true
+```
+
+## Universal Distance and Bearing Methods
+
+H3 supports all universal distance and bearing methods via the `DistanceMethods` and `BearingMethods` mixins:
+
+```ruby
+a = H3.new("872a1072bffffff")     # Statue of Liberty area
+b = H3.new("87195da49ffffff")     # London area
+
+a.distance_to(b)                # => Distance (~5,570 km)
+a.straight_line_distance_to(b)  # => Distance
+a.bearing_to(b)                 # => Bearing
+a.elevation_to(b)               # => Float (degrees)
+```
+
+## Well-Known H3 Cells
+
+| Location | H3 Index (res 7) | Resolution |
+|----------|------------------|------------|
+| Statue of Liberty | `872a1072bffffff` | 7 |
+| London | `87195da49ffffff` | 7 |
+| Null Island (0, 0) | `87754e64dffffff` | 7 |
+
+## Implementation Notes
+
+Geodetic uses Ruby's `fiddle` (part of the standard library) to call the H3 v4 C API directly. No gem dependency beyond `fiddle` is required. The H3 C library must be installed separately.
+
+The library search order is:
+1. `LIBH3_PATH` environment variable
+2. `/opt/homebrew/lib/libh3.dylib` (macOS ARM)
+3. `/usr/local/lib/libh3.dylib` (macOS Intel)
+4. `/usr/lib/libh3.so` (Linux)
+5. `/usr/local/lib/libh3.so` (Linux local)
+6. Architecture-specific Linux paths

data/docs/coordinate-systems/index.md

@@ -1,6 +1,6 @@
 # Coordinate Systems Overview
 
-The Geodetic gem supports 17 coordinate systems organized into six categories. All coordinate classes live under `Geodetic::Coordinate`.
+The Geodetic gem supports 18 coordinate systems organized into six categories. All coordinate classes live under `Geodetic::Coordinate`.
 
 ## Global Systems
 
@@ -46,6 +46,7 @@ The Geodetic gem supports 17 coordinate systems organized into six categories. A
 | **OLC** | `Geodetic::Coordinate::OLC` | Open Location Code (Plus Codes). Google's open system for encoding locations into short codes like `849VCWC8+R9`. Uses a 20-character alphabet with 5 paired levels of base-20 encoding plus optional grid refinement. Includes a `+` separator at position 8. Supports neighbor lookup, area extraction, and configurable precision (default 10 characters for ~14 m resolution). |
 | **GEOREF** | `Geodetic::Coordinate::GEOREF` | World Geographic Reference System. A geocode system used in aviation and military applications that encodes positions using letter tiles (15° grid), letter degree subdivisions, and numeric minute pairs. Uses a 24-letter alphabet (A-Z excluding I and O). Supports variable precision from 15° tiles (2 chars) down to 0.01-minute resolution (12 chars). Default precision is 8 characters (1-minute resolution). |
 | **GARS** | `Geodetic::Coordinate::GARS` | Global Area Reference System. An NGA standard that divides the world into 30-minute cells identified by a 3-digit longitude band (001-720) and 2-letter latitude band. Cells are subdivided into 15-minute quadrants (1-4) and 5-minute keypads (1-9, telephone layout). Variable precision: 5 chars (30'), 6 chars (15'), 7 chars (5'). Default precision is 7 characters. |
+| **H3** | `Geodetic::Coordinate::H3` | H3 Hexagonal Hierarchical Index. Uber's spatial indexing system that divides the globe into hexagonal cells (and 12 pentagons) at 16 resolution levels (0-15). Each cell is a 64-bit integer displayed as a hex string. Unlike the rectangular spatial hashes, `to_area` returns an `Areas::Polygon` with 6 vertices (5 for pentagons) and `neighbors` returns an Array of 6 cells. **Requires `libh3` installed** (`brew install h3` on macOS). |
 
 ## Regional Systems
 
@@ -60,25 +61,26 @@ The Geodetic gem supports 17 coordinate systems organized into six categories. A
 
 Every coordinate system can convert to every other coordinate system. The table below confirms full interoperability:
 
-| From \ To | LLA | ECEF | UTM | ENU | NED | MGRS | USNG | WebMercator | UPS | StatePlane | BNG | GH36 | GH | HAM | OLC | GEOREF | GARS |
-|-----------|-----|------|-----|-----|-----|------|------|-------------|-----|------------|-----|------|----|----|-----|--------|------|
-| **LLA**        | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| **ECEF**       | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| **UTM**        | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| **ENU**        | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| **NED**        | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| **MGRS**       | Y | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| **USNG**       | Y | Y | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| **WebMercator**| Y | Y | Y | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| **UPS**        | Y | Y | Y | Y | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y |
-| **StatePlane** | Y | Y | Y | Y | Y | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y |
-| **BNG**        | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y |
-| **GH36**       | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y |
-| **GH**         | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | -- | Y | Y | Y | Y |
-| **HAM**        | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | -- | Y | Y | Y |
-| **OLC**        | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | -- | Y | Y |
-| **GEOREF**     | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | -- | Y |
-| **GARS**       | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | -- |
+| From \ To | LLA | ECEF | UTM | ENU | NED | MGRS | USNG | WebMercator | UPS | StatePlane | BNG | GH36 | GH | HAM | OLC | GEOREF | GARS | H3 |
+|-----------|-----|------|-----|-----|-----|------|------|-------------|-----|------------|-----|------|----|----|-----|--------|------|-----|
+| **LLA**        | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
+| **ECEF**       | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
+| **UTM**        | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
+| **ENU**        | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
+| **NED**        | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
+| **MGRS**       | Y | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
+| **USNG**       | Y | Y | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
+| **WebMercator**| Y | Y | Y | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
+| **UPS**        | Y | Y | Y | Y | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y | Y |
+| **StatePlane** | Y | Y | Y | Y | Y | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y | Y |
+| **BNG**        | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y | Y |
+| **GH36**       | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | --  | Y | Y | Y | Y | Y | Y |
+| **GH**         | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | -- | Y | Y | Y | Y | Y |
+| **HAM**        | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | -- | Y | Y | Y | Y |
+| **OLC**        | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | -- | Y | Y | Y |
+| **GEOREF**     | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | -- | Y | Y |
+| **GARS**       | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | -- | Y |
+| **H3**         | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | -- |
 
 ## Universal Distance and Bearing Calculations
 
@@ -98,6 +100,6 @@ Conversions typically route through **LLA** or **ECEF** as intermediate steps:
 - **ECEF** is the intermediate for local tangent plane systems (ENU, NED), since the rotation from global Cartesian to local frames is straightforward in ECEF.
 - **ENU and NED** convert between each other directly by reordering axes and inverting the vertical component.
 - **MGRS and USNG** route through UTM, which in turn routes through LLA.
-- **WebMercator, UPS, BNG, StatePlane, GH36, GH, HAM, OLC, GEOREF, and GARS** all convert through LLA.
+- **WebMercator, UPS, BNG, StatePlane, GH36, GH, HAM, OLC, GEOREF, GARS, and H3** all convert through LLA.
 
 For example, converting from BNG to NED follows the chain: `BNG -> LLA -> ECEF -> ENU -> NED`. The gem handles this automatically when you call a conversion method.

data/docs/index.md

@@ -9,7 +9,7 @@
 <td width="50%" valign="top">
 <h2>Key Features</h2>
 <lu>
-<li><strong>17 Coordinate Systems</strong> - LLA, ECEF, UTM, ENU, NED, MGRS, USNG, Web Mercator, UPS, State Plane, BNG, GH36, GH, HAM, OLC<br>
+<li><strong>18 Coordinate Systems</strong> - LLA, ECEF, UTM, ENU, NED, MGRS, USNG, Web Mercator, UPS, State Plane, BNG, GH36, GH, HAM, OLC<br>
 <li><strong>Full Bidirectional Conversions</strong> - Every system converts to and from every other system<br>
 <li><strong>Distance Calculations</strong> - Vincenty great-circle and straight-line with unit tracking<br>
 <li><strong>Bearing Calculations</strong> - Forward azimuth, back azimuth, compass directions, elevation angles<br>
@@ -24,11 +24,11 @@
 </tr>
 </table>
 
-Geodetic is a Ruby gem for converting between geodetic coordinate systems. It provides a clean, consistent API for working with 17 coordinate systems, 16 geodetic datums, geoid height calculations, and geographic area computations.
+Geodetic is a Ruby gem for converting between geodetic coordinate systems. It provides a clean, consistent API for working with 18 coordinate systems, 16 geodetic datums, geoid height calculations, and geographic area computations.
 
 ## Coordinate Systems
 
-Geodetic supports full bidirectional conversion between all 17 coordinate systems:
+Geodetic supports full bidirectional conversion between all 18 coordinate systems:
 
 | System | Class | Description |
 |--------|-------|-------------|
@@ -49,6 +49,7 @@ Geodetic supports full bidirectional conversion between all 17 coordinate system
 | **OLC** | `Geodetic::Coordinate::OLC` | Open Location Code / Plus Codes (Google's location encoding) |
 | **GEOREF** | `Geodetic::Coordinate::GEOREF` | World Geographic Reference System (aviation/military) |
 | **GARS** | `Geodetic::Coordinate::GARS` | Global Area Reference System (NGA standard) |
+| **H3** | `Geodetic::Coordinate::H3` | Uber's hexagonal hierarchical index (requires `libh3`) |
 
 ## Additional Features
 

data/lib/geodetic/coordinate/enu.rb

@@ -212,6 +212,15 @@ module Geodetic
         from_lla(lla, reference_lla)
       end
 
+      def to_h3(reference_lla, precision: 7)
+        H3.new(to_lla(reference_lla), precision: precision)
+      end
+
+      def self.from_h3(h3_coord, reference_lla)
+        lla = h3_coord.to_lla
+        from_lla(lla, reference_lla)
+      end
+
       def to_s(precision = 2)
         precision = precision.to_i
         if precision == 0

data/lib/geodetic/coordinate/h3.rb

@@ -0,0 +1,413 @@
+# frozen_string_literal: true
+
+# H3 (Uber's Hexagonal Hierarchical Spatial Index) Coordinate
+#
+# A hierarchical geospatial index that divides the globe into hexagonal cells
+# (and 12 pentagons) at 16 resolution levels (0-15). Each cell is identified
+# by a 64-bit integer (H3Index), typically displayed as a 15-character hex string.
+#
+# REQUIRES: libh3 shared library (brew install h3)
+# Uses Ruby's fiddle (stdlib) to call H3 v4 C API — no gem dependency.
+#
+# Key differences from other spatial hashes:
+#   - Cells are hexagons (6 vertices), not rectangles
+#   - to_area returns Areas::Polygon, not Areas::Rectangle
+#   - neighbors returns an Array (6 cells), not a directional Hash
+#   - "precision" maps to H3 resolution (0-15), not string length
+#
+# Usage:
+#   H3.new("872a1072bffffff")              # from hex string
+#   H3.new(0x872a1072bffffff)              # from integer
+#   H3.new(lla_coord)                      # from any coordinate
+#   H3.new(lla_coord, precision: 9)        # resolution 9
+
+require_relative 'spatial_hash'
+
+module Geodetic
+  module Coordinate
+    class H3 < SpatialHash
+      # --- FFI bindings to libh3 via fiddle ---
+
+      module LibH3
+        require 'fiddle'
+
+        SEARCH_PATHS = [
+          ENV['LIBH3_PATH'],
+          '/opt/homebrew/lib/libh3.dylib',
+          '/opt/homebrew/lib/libh3.1.dylib',
+          '/usr/local/lib/libh3.dylib',
+          '/usr/local/lib/libh3.1.dylib',
+          '/usr/lib/libh3.so',
+          '/usr/lib/libh3.so.1',
+          '/usr/local/lib/libh3.so',
+          '/usr/local/lib/libh3.so.1',
+          '/usr/lib/x86_64-linux-gnu/libh3.so',
+          '/usr/lib/aarch64-linux-gnu/libh3.so',
+        ].compact.freeze
+
+        @handle = nil
+        @available = false
+
+        class << self
+          attr_reader :handle
+
+          def available?
+            @available
+          end
+
+          def require_library!
+            return if @available
+            raise Geodetic::Error,
+              "libh3 not found. Install H3: brew install h3 (macOS) " \
+              "or see https://h3geo.org/docs/installation. " \
+              "Set LIBH3_PATH env var to specify a custom library path."
+          end
+        end
+
+        begin
+          path = SEARCH_PATHS.find { |p| File.exist?(p) }
+          if path
+            @handle = Fiddle.dlopen(path)
+            @available = true
+          end
+        rescue Fiddle::DLError
+          @available = false
+        end
+
+        # Struct sizes
+        SIZEOF_LATLNG = 2 * Fiddle::SIZEOF_DOUBLE          # 16 bytes
+        SIZEOF_CELL_BOUNDARY = 8 + 10 * SIZEOF_LATLNG       # 168 bytes (int + pad + 10 LatLngs)
+        SIZEOF_H3INDEX = Fiddle::SIZEOF_LONG_LONG            # 8 bytes
+        SIZEOF_INT64 = Fiddle::SIZEOF_LONG_LONG              # 8 bytes
+
+        # Function bindings (lazy-loaded)
+        def self.bind(name, args, ret)
+          return nil unless @available
+          ptr = @handle[name]
+          Fiddle::Function.new(ptr, args, ret)
+        rescue Fiddle::DLError
+          nil
+        end
+
+        # H3Error latLngToCell(const LatLng *g, int res, H3Index *out)
+        F_LAT_LNG_TO_CELL = bind('latLngToCell',
+          [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_INT)
+
+        # H3Error cellToLatLng(H3Index h3, LatLng *g)
+        F_CELL_TO_LAT_LNG = bind('cellToLatLng',
+          [Fiddle::TYPE_LONG_LONG, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_INT)
+
+        # H3Error cellToBoundary(H3Index h3, CellBoundary *gp)
+        F_CELL_TO_BOUNDARY = bind('cellToBoundary',
+          [Fiddle::TYPE_LONG_LONG, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_INT)
+
+        # int getResolution(H3Index h)
+        F_GET_RESOLUTION = bind('getResolution',
+          [Fiddle::TYPE_LONG_LONG],
+          Fiddle::TYPE_INT)
+
+        # int isValidCell(H3Index h)
+        F_IS_VALID_CELL = bind('isValidCell',
+          [Fiddle::TYPE_LONG_LONG],
+          Fiddle::TYPE_INT)
+
+        # int isPentagon(H3Index h)
+        F_IS_PENTAGON = bind('isPentagon',
+          [Fiddle::TYPE_LONG_LONG],
+          Fiddle::TYPE_INT)
+
+        # H3Error gridDisk(H3Index origin, int k, H3Index *out)
+        F_GRID_DISK = bind('gridDisk',
+          [Fiddle::TYPE_LONG_LONG, Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_INT)
+
+        # H3Error maxGridDiskSize(int k, int64_t *out)
+        F_MAX_GRID_DISK_SIZE = bind('maxGridDiskSize',
+          [Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_INT)
+
+        # H3Error cellAreaM2(H3Index h, double *out)
+        F_CELL_AREA_M2 = bind('cellAreaM2',
+          [Fiddle::TYPE_LONG_LONG, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_INT)
+
+        # H3Error cellToParent(H3Index h, int parentRes, H3Index *out)
+        F_CELL_TO_PARENT = bind('cellToParent',
+          [Fiddle::TYPE_LONG_LONG, Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_INT)
+
+        # H3Error cellToChildrenSize(H3Index h, int childRes, int64_t *out)
+        F_CELL_TO_CHILDREN_SIZE = bind('cellToChildrenSize',
+          [Fiddle::TYPE_LONG_LONG, Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_INT)
+
+        # H3Error cellToChildren(H3Index h, int childRes, H3Index *out)
+        F_CELL_TO_CHILDREN = bind('cellToChildren',
+          [Fiddle::TYPE_LONG_LONG, Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_INT)
+
+        # --- High-level wrappers ---
+
+        def self.lat_lng_to_cell(lat_rad, lng_rad, resolution)
+          require_library!
+          latlng = Fiddle::Pointer.malloc(SIZEOF_LATLNG, Fiddle::RUBY_FREE)
+          latlng[0, SIZEOF_LATLNG] = [lat_rad, lng_rad].pack('d2')
+          out = Fiddle::Pointer.malloc(SIZEOF_H3INDEX, Fiddle::RUBY_FREE)
+          err = F_LAT_LNG_TO_CELL.call(latlng, resolution, out)
+          raise ArgumentError, "H3 latLngToCell error (code #{err})" unless err == 0
+          out[0, SIZEOF_H3INDEX].unpack1('Q')
+        end
+
+        def self.cell_to_lat_lng(h3_index)
+          require_library!
+          latlng = Fiddle::Pointer.malloc(SIZEOF_LATLNG, Fiddle::RUBY_FREE)
+          err = F_CELL_TO_LAT_LNG.call(h3_index, latlng)
+          raise ArgumentError, "H3 cellToLatLng error (code #{err})" unless err == 0
+          lat_rad, lng_rad = latlng[0, SIZEOF_LATLNG].unpack('d2')
+          { lat: lat_rad * DEG_PER_RAD, lng: lng_rad * DEG_PER_RAD }
+        end
+
+        def self.cell_to_boundary(h3_index)
+          require_library!
+          cb = Fiddle::Pointer.malloc(SIZEOF_CELL_BOUNDARY, Fiddle::RUBY_FREE)
+          err = F_CELL_TO_BOUNDARY.call(h3_index, cb)
+          raise ArgumentError, "H3 cellToBoundary error (code #{err})" unless err == 0
+          num_verts = cb[0, 4].unpack1('i')
+          # Vertices start at offset 8 (4 byte int + 4 byte padding)
+          verts = cb[8, num_verts * SIZEOF_LATLNG].unpack("d#{num_verts * 2}")
+          (0...num_verts).map do |i|
+            { lat: verts[i * 2] * DEG_PER_RAD, lng: verts[i * 2 + 1] * DEG_PER_RAD }
+          end
+        end
+
+        def self.get_resolution(h3_index)
+          require_library!
+          F_GET_RESOLUTION.call(h3_index)
+        end
+
+        def self.is_valid_cell(h3_index)
+          require_library!
+          F_IS_VALID_CELL.call(h3_index) == 1
+        end
+
+        def self.is_pentagon(h3_index)
+          require_library!
+          F_IS_PENTAGON.call(h3_index) == 1
+        end
+
+        def self.grid_disk(h3_index, k)
+          require_library!
+          size_ptr = Fiddle::Pointer.malloc(SIZEOF_INT64, Fiddle::RUBY_FREE)
+          err = F_MAX_GRID_DISK_SIZE.call(k, size_ptr)
+          raise ArgumentError, "H3 maxGridDiskSize error (code #{err})" unless err == 0
+          max_size = size_ptr[0, SIZEOF_INT64].unpack1('q')
+
+          out = Fiddle::Pointer.malloc(max_size * SIZEOF_H3INDEX, Fiddle::RUBY_FREE)
+          err = F_GRID_DISK.call(h3_index, k, out)
+          raise ArgumentError, "H3 gridDisk error (code #{err})" unless err == 0
+
+          out[0, max_size * SIZEOF_H3INDEX].unpack("Q#{max_size}").reject(&:zero?)
+        end
+
+        def self.cell_area_m2(h3_index)
+          require_library!
+          out = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE, Fiddle::RUBY_FREE)
+          err = F_CELL_AREA_M2.call(h3_index, out)
+          raise ArgumentError, "H3 cellAreaM2 error (code #{err})" unless err == 0
+          out[0, Fiddle::SIZEOF_DOUBLE].unpack1('d')
+        end
+
+        def self.cell_to_parent(h3_index, parent_res)
+          require_library!
+          out = Fiddle::Pointer.malloc(SIZEOF_H3INDEX, Fiddle::RUBY_FREE)
+          err = F_CELL_TO_PARENT.call(h3_index, parent_res, out)
+          raise ArgumentError, "H3 cellToParent error (code #{err})" unless err == 0
+          out[0, SIZEOF_H3INDEX].unpack1('Q')
+        end
+
+        def self.cell_to_children(h3_index, child_res)
+          require_library!
+          size_ptr = Fiddle::Pointer.malloc(SIZEOF_INT64, Fiddle::RUBY_FREE)
+          err = F_CELL_TO_CHILDREN_SIZE.call(h3_index, child_res, size_ptr)
+          raise ArgumentError, "H3 cellToChildrenSize error (code #{err})" unless err == 0
+          count = size_ptr[0, SIZEOF_INT64].unpack1('q')
+
+          out = Fiddle::Pointer.malloc(count * SIZEOF_H3INDEX, Fiddle::RUBY_FREE)
+          err = F_CELL_TO_CHILDREN.call(h3_index, child_res, out)
+          raise ArgumentError, "H3 cellToChildren error (code #{err})" unless err == 0
+
+          out[0, count * SIZEOF_H3INDEX].unpack("Q#{count}").reject(&:zero?)
+        end
+      end
+
+      # --- Class configuration ---
+
+      attr_reader :code
+
+      def self.default_precision = 7
+      def self.hash_system_name = :h3
+
+      def self.available?
+        LibH3.available?
+      end
+
+      # --- Constructor ---
+
+      def initialize(source, precision: self.class.default_precision)
+        case source
+        when Integer
+          hex = format('%x', source)
+          validate_code!(hex)
+          set_code(hex)
+        when String
+          normalized = normalize(source.strip)
+          validate_code!(normalized)
+          set_code(normalized)
+        when LLA
+          set_code(encode(source.lat, source.lng, precision))
+        else
+          if source.respond_to?(:to_lla)
+            lla = source.to_lla
+            set_code(encode(lla.lat, lla.lng, precision))
+          else
+            raise ArgumentError,
+              "Expected an H3 hex String, Integer, or coordinate object, got #{source.class}"
+          end
+        end
+      end
+
+      # --- H3-specific methods ---
+
+      # The 64-bit H3 cell index
+      def h3_index
+        @h3_index ||= code.to_i(16)
+      end
+
+      # H3 resolution (0-15)
+      def precision
+        @resolution ||= LibH3.get_resolution(h3_index)
+      end
+      alias_method :resolution, :precision
+
+      # Is this cell a pentagon? (12 per resolution level)
+      def pentagon?
+        LibH3.is_pentagon(h3_index)
+      end
+
+      # Parent cell at a coarser resolution
+      def parent(parent_resolution)
+        raise ArgumentError, "Parent resolution must be < #{resolution}" unless parent_resolution < resolution
+        parent_idx = LibH3.cell_to_parent(h3_index, parent_resolution)
+        self.class.new(parent_idx)
+      end
+
+      # Child cells at a finer resolution
+      def children(child_resolution)
+        raise ArgumentError, "Child resolution must be > #{resolution}" unless child_resolution > resolution
+        child_indices = LibH3.cell_to_children(h3_index, child_resolution)
+        child_indices.map { |idx| self.class.new(idx) }
+      end
+
+      # All cells within k steps (k=0 returns self, k=1 returns 7 cells, etc.)
+      def grid_disk(k = 1)
+        indices = LibH3.grid_disk(h3_index, k)
+        indices.map { |idx| self.class.new(idx) }
+      end
+
+      # Cell area in square meters
+      def cell_area
+        LibH3.cell_area_m2(h3_index)
+      end
+
+      # --- Override SpatialHash methods ---
+
+      def valid?
+        LibH3.is_valid_cell(h3_index)
+      end
+
+      # Returns all adjacent cells as an Array of H3 instances.
+      # Hexagons have 6 neighbors; pentagons have 5.
+      # Note: returns Array, not directional Hash (hexagons have no cardinal directions).
+      def neighbors
+        indices = LibH3.grid_disk(h3_index, 1)
+        indices.reject { |idx| idx == h3_index }.map { |idx| self.class.new(idx) }
+      end
+
+      # Returns the hexagonal cell boundary as an Areas::Polygon.
+      def to_area
+        verts = LibH3.cell_to_boundary(h3_index)
+        boundary = verts.map { |v| LLA.new(lat: v[:lat], lng: v[:lng], alt: 0.0) }
+        Areas::Polygon.new(boundary: boundary)
+      end
+
+      # Returns approximate precision in meters as { lat:, lng:, area_m2: }
+      def precision_in_meters
+        area = cell_area
+        edge = Math.sqrt(area)
+        { lat: edge, lng: edge, area_m2: area }
+      end
+
+      def to_s(format = nil)
+        if format == :integer
+          h3_index
+        else
+          code
+        end
+      end
+
+      def code_value
+        @code
+      end
+
+      protected
+
+      def normalize(string)
+        string.downcase.delete_prefix('0x')
+      end
+
+      def set_code(value)
+        @code = value
+        @h3_index = nil
+        @resolution = nil
+      end
+
+      private
+
+      def encode(lat, lng, resolution = self.class.default_precision)
+        resolution = resolution.clamp(0, 15)
+        lat_rad = lat * RAD_PER_DEG
+        lng_rad = lng * RAD_PER_DEG
+        idx = LibH3.lat_lng_to_cell(lat_rad, lng_rad, resolution)
+        format('%x', idx)
+      end
+
+      def decode(code_string)
+        idx = code_string.to_i(16)
+        LibH3.cell_to_lat_lng(idx)
+      end
+
+      def decode_bounds(code_string)
+        idx = code_string.to_i(16)
+        verts = LibH3.cell_to_boundary(idx)
+        lats = verts.map { |v| v[:lat] }
+        lngs = verts.map { |v| v[:lng] }
+        { min_lat: lats.min, max_lat: lats.max, min_lng: lngs.min, max_lng: lngs.max }
+      end
+
+      def validate_h3!(code_string)
+        raise ArgumentError, "H3 code cannot be empty" if code_string.empty?
+        raise ArgumentError, "Invalid H3 hex string: #{code_string}" unless code_string.match?(/\A[0-9a-f]+\z/)
+        idx = code_string.to_i(16)
+        raise ArgumentError, "Invalid H3 cell index: #{code_string}" unless LibH3.is_valid_cell(idx)
+      end
+
+      alias_method :validate_code!, :validate_h3!
+
+      register_hash_system(:h3, self, default_precision: 7)
+      Coordinate.register_class(self)
+    end
+  end
+end

data/lib/geodetic/coordinate/lla.rb

@@ -270,6 +270,14 @@ module Geodetic
         gars_coord.to_lla(datum)
       end
 
+      def to_h3(precision: 7)
+        H3.new(self, precision: precision)
+      end
+
+      def self.from_h3(h3_coord, datum = WGS84)
+        h3_coord.to_lla(datum)
+      end
+
       def self.from_lla(lla_coord, datum = WGS84)
         lla_coord
       end

data/lib/geodetic/coordinate/ned.rb

@@ -193,6 +193,15 @@ module Geodetic
         from_lla(lla, reference_lla)
       end
 
+      def to_h3(reference_lla, precision: 7)
+        H3.new(to_lla(reference_lla), precision: precision)
+      end
+
+      def self.from_h3(h3_coord, reference_lla)
+        lla = h3_coord.to_lla
+        from_lla(lla, reference_lla)
+      end
+
       def to_s(precision = 2)
         precision = precision.to_i
         if precision == 0

data/lib/geodetic/coordinate/state_plane.rb

@@ -305,6 +305,15 @@ module Geodetic
         from_lla(lla_coord, zone_code, datum)
       end
 
+      def to_h3(datum = nil, precision: 7)
+        H3.new(to_lla(datum), precision: precision)
+      end
+
+      def self.from_h3(h3_coord, zone_code, datum = WGS84)
+        lla_coord = h3_coord.to_lla(datum)
+        from_lla(lla_coord, zone_code, datum)
+      end
+
       # Unit conversion methods
       def to_meters
         zone_info = ZONES[@zone_code]

data/lib/geodetic/coordinate.rb

@@ -33,6 +33,7 @@ require_relative "coordinate/ham"
 require_relative "coordinate/olc"
 require_relative "coordinate/georef"
 require_relative "coordinate/gars"
+require_relative "coordinate/h3"
 
 module Geodetic
   module Coordinate

data/lib/geodetic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Geodetic
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: geodetic
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -9,11 +9,11 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: A Ruby gem for converting between 17 geodetic coordinate systems (LLA,
+description: A Ruby gem for converting between 18 geodetic coordinate systems (LLA,
   ECEF, UTM, ENU, NED, MGRS, USNG, Web Mercator, UPS, State Plane, BNG, GH36, GH,
-  HAM, OLC, GEOREF, GARS) with Vincenty great-circle and ECEF Euclidean distance calculations,
-  unit-aware Distance and Bearing classes, geoid height support, and geographic area
-  operations.
+  HAM, OLC, GEOREF, GARS, H3) with Vincenty great-circle and ECEF Euclidean distance
+  calculations, unit-aware Distance and Bearing classes, geoid height support, and
+  geographic area operations.
 email:
 - dewayne@vanhoozer.me
 executables: []
@@ -35,6 +35,7 @@ files:
 - docs/coordinate-systems/georef.md
 - docs/coordinate-systems/gh.md
 - docs/coordinate-systems/gh36.md
+- docs/coordinate-systems/h3.md
 - docs/coordinate-systems/ham.md
 - docs/coordinate-systems/index.md
 - docs/coordinate-systems/lla.md
@@ -72,6 +73,7 @@ files:
 - lib/geodetic/coordinate/georef.rb
 - lib/geodetic/coordinate/gh.rb
 - lib/geodetic/coordinate/gh36.rb
+- lib/geodetic/coordinate/h3.rb
 - lib/geodetic/coordinate/ham.rb
 - lib/geodetic/coordinate/lla.rb
 - lib/geodetic/coordinate/mgrs.rb