SwiftNav

https://github.com/swift-nav/swiftnav-rs
Admin
SwiftNav is a Rust crate that implements GNSS utility functions for software-defined GNSS receivers...
Tokens:11,201
Snippets:52
Trust Score:8.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Convert Between GPS, Galileo, and BeiDou Time

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Shows how to convert between GpsTime, GalTime, and BdsTime. Also demonstrates accessing the start epochs for Galileo and BeiDou time systems relative to GPS time.

```rust
use swiftnav::time::{GpsTime, GalTime, BdsTime, GAL_TIME_START, BDS_TIME_START};

// GPS → Galileo
let gps = GpsTime::new(1500, 0.0).unwrap();
let gal = gps.to_gal();
println!("GAL WN: {}", gal.wn()); // GPS wn minus Galileo week offset

// GPS → BeiDou
let bds = gps.to_bds();
println!("BDS WN: {}, TOW: {:.3}", bds.wn(), bds.tow());

// Round-trip
let gps_back: GpsTime = gal.to_gps();
println!("Round-trip diff: {}", gps.diff(&gps_back)); // ~0.0

// Start epochs
println!("GAL starts at GPS WN: {}", GAL_TIME_START.wn());
println!("BDS starts at GPS WN: {}", BDS_TIME_START.wn());
```

--------------------------------

### Identify GNSS signals with GnssSignal in Rust

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Demonstrates the creation and inspection of `GnssSignal` objects, which represent a unique satellite and code pair. Includes examples of retrieving carrier frequencies, handling GLONASS channel frequencies, and parsing codes from strings. Note that invalid PRNs will result in an error.

```rust
use swiftnav::signal::{GnssSignal, Code, Constellation};
use std::str::FromStr;

// Create and inspect
let sig = GnssSignal::new(22, Code::GpsL1ca).expect("valid PRN for GPS");
println!("{}", sig);                          // "GPS L1CA 22"
println!("{:?}", sig.to_constellation());    // Gps
println!("Freq: {} Hz", sig.get_carrier_frequency()); // 1575420000.0

// GLONASS channel frequency (FDMA, slot -7..+6)
let glo = GnssSignal::new(5, Code::GloL1of).unwrap();
let ch_freq = glo.get_glo_channel_frequency(3);
println!("GLO ch3 L1: {} Hz", ch_freq);

// Invalid PRN → error
let bad = GnssSignal::new(99, Code::GpsL1ca);
assert!(bad.is_err());

// Constellation satellite counts
println!("GPS sats: {}", Constellation::Gps.sat_count());   // 32
println!("GAL sats: {}", Constellation::Gal.sat_count());   // 36
println!("BDS sats: {}", Constellation::Bds.sat_count());   // 63

// Parse Code from string
let code = Code::from_str("BDS3 B1C").unwrap();
println!("Freq: {:.2e} Hz", code.get_carrier_frequency()); // 1.58e9
```

--------------------------------

### Handle UtcTime and MJD: Construction and Conversion

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Demonstrates creating UtcTime from date parts and converting between UtcTime, MJD, and GpsTime. Includes round-trip conversion validation.

```rust
use swiftnav::time::{UtcTime, MJD};

// Construct UTC from parts
let utc = UtcTime::from_parts(2025, 3, 15, 12, 30, 45.5);
let (y, mo, d, h, mi, s) = utc.to_date();
println!("{y}-{mo:02}-{d:02} {h:02}:{mi:02}:{s:.1}"); // 2025-03-15 12:30:45.5

// UTC → MJD → GPS
let mjd = utc.to_mjd();
println!("MJD: {:.6}", mjd.as_f64());

let gps = mjd.to_gps_hardcoded();
println!("GPS WN: {}, TOW: {:.2}", gps.wn(), gps.tow());

// GPS → UTC round-trip
let utc2 = gps.to_utc_hardcoded();
let mjd2 = utc2.to_mjd();
let diff = (mjd.as_f64() - mjd2.as_f64()).abs();
assert!(diff < 1e-9, "Round-trip error: {diff}");

// MJD from date parts
let mjd3 = MJD::from_parts(2025, 3, 15, 12, 30, 45.5);
println!("MJD: {:.6}", mjd3.as_f64());
```

--------------------------------

### Render Math in HTML with KaTeX

Source: https://github.com/swift-nav/swiftnav-rs/blob/master/katex-header.html

Use this JavaScript snippet to initialize KaTeX rendering on your HTML document. It configures the delimiters for inline and display math.

```javascript
document.addEventListener("DOMContentLoaded", function() { renderMathInElement(document.body, { delimiters: [
  {left: "$$", right: "$$", display: true},
  {left: "\\(", right: "\\)", display: false},
  {left: "$", right: "$", display: false},
  {left: " H", right: " H", display: true}
] }); });
```

--------------------------------

### Configure KaTeX Rendering

Source: https://github.com/swift-nav/swiftnav-rs/blob/master/swiftnav/katex-header.html

Use this JavaScript to initialize KaTeX rendering for mathematical expressions on your page. It defines delimiters for inline and display math modes.

```javascript
document.addEventListener("DOMContentLoaded", function() { renderMathInElement(document.body, { delimiters: [
  {left: "$$", right: "$$", display: true},
  {left: "\\(", right: "\\)", display: false},
  {left: "$", right: "$", display: false},
  {left: "\[", right: "\]", display: true}
] }); });
```

--------------------------------

### Manipulate GpsTime: Creation, Arithmetic, and Conversion

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Demonstrates creating, performing arithmetic on, and converting GpsTime. Supports operations like adding/subtracting durations, snapping to epochs, and converting to/from UTC.

```rust
use swiftnav::time::{GpsTime, UtcTime};
use std::time::Duration;

// Create and validate
let t = GpsTime::new(2345, 345_600.0).expect("valid GPS time");
println!("WN: {}, TOW: {}", t.wn(), t.tow()); // WN: 2345, TOW: 345600.0

// Arithmetic
let t2 = t + Duration::from_secs(3600);    // add one hour
let t3 = t - Duration::from_secs(60);      // subtract one minute
println!("Diff: {} s", t2.diff(&t3));       // 3660.0

// Snap to solution epoch (e.g., 10 Hz)
let snapped = t.round_to_epoch(10.0);
let floored = t.floor_to_epoch(10.0);

// Convert to UTC (hardcoded leap seconds)
let utc = t.to_utc_hardcoded();
let (year, month, day, hour, min, sec) = utc.to_date();
println!("{year}-{month:02}-{day:02} {hour:02}:{min:02}:{sec:06.3}");

// Convert from calendar date
let t_from_date = GpsTime::from_parts_hardcoded(2025, 6, 15, 12, 0, 0.0);
println!("WN: {}, TOW: {:.1}", t_from_date.wn(), t_from_date.tow());

// Leap second detection
println!("LSE: {}", t.is_leap_second_event_hardcoded()); // false
```

--------------------------------

### ECEF Vector Operations and Conversions

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Shows how to perform vector operations and conversions using ECEF coordinates. Includes calculating NED vectors and azimuth/elevation between points, and propagating position using velocity.

```rust
use swiftnav::coords::{ECEF, LLHDegrees};

let origin = LLHDegrees::new(37.7749, -122.4194, 10.0).to_ecef();
let target = LLHDegrees::new(37.7551, -122.4477, 254.0).to_ecef(); // Sutro Tower

// Compute NED vector from origin to target
let ned = origin.ned_to(&target);
println!("N: {:.1}m, E: {:.1}m, D: {:.1}m", ned.n(), ned.e(), ned.d());

// Compute azimuth/elevation from origin to target
let azel = origin.azel_of(&target);
println!("Az: {:.4} rad, El: {:.4} rad", azel.az(), azel.el());

// Arithmetic: propagate position using velocity (m/year)
let velocity = ECEF::new(-0.021, 0.015, 0.009); // crustal velocity
let years = 5.0;
let future_pos = origin + (years * velocity);
println!("Future: ({:.2}, {:.2}, {:.2})", future_pos.x(), future_pos.y(), future_pos.z());

// Convert ECEF velocity vector to NED local frame
let v_ned = velocity.ned_vector_at(&origin);
println!("V_N: {:.4} m/yr, V_E: {:.4} m/yr, V_D: {:.4} m/yr",
    v_ned.n(), v_ned.e(), v_ned.d());
```

--------------------------------

### LLHDegrees/LLHRadians to ECEF Conversion

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Demonstrates creating geodetic coordinates in degrees or radians, converting between them, and transforming to Earth-Centered, Earth-Fixed (ECEF) Cartesian coordinates. Also shows round-trip conversion and construction from arrays/tuples.

```rust
use swiftnav::coords::{LLHDegrees, LLHRadians, ECEF};

// Create from degrees
let sf = LLHDegrees::new(37.7749, -122.4194, 10.0);
println!("Lat: {}, Lon: {}", sf.latitude(), sf.longitude()); // 37.7749, -122.4194

// Convert to radians
let sf_rad: LLHRadians = sf.to_radians();
println!("Lat rad: {:.6}", sf_rad.latitude()); // 0.659389

// Convert to ECEF
let sf_ecef: ECEF = sf.to_ecef();
println!("ECEF: ({:.1}, {:.1}, {:.1})", sf_ecef.x(), sf_ecef.y(), sf_ecef.z());
// ECEF: (-2711206.2, -4260069.0, 3886079.7)

// Round-trip: ECEF → LLH
let back: LLHDegrees = sf_ecef.to_llh().to_degrees();
assert!((back.latitude() - sf.latitude()).abs() < 1e-9);

// Construct from array or tuple
let p: LLHDegrees = [37.0, -122.0, 50.0].into();
let q: LLHDegrees = (37.0, -122.0, 50.0).into();

// Degree-decimal-minutes breakdown (for NMEA formatting)
let (deg, mins) = sf.latitude_degree_decimal_minutes();
println!("{deg}° {mins:.4}' {}", sf.latitudinal_hemisphere()); // 37° 46.4940' N
```

--------------------------------

### NED Vector Construction and Conversion

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Illustrates how to construct a North-East-Down (NED) local-frame vector and convert it back to an ECEF vector relative to a specified reference point.

```rust
use swiftnav::coords::{NED, LLHDegrees};

let ref_pos = LLHDegrees::new(37.7749, -122.4194, 10.0).to_ecef();

// Build NED vector: 100m north, 50m east, 0m down
let ned = NED::new(100.0, 50.0, 0.0);

// Convert back to ECEF vector at reference point
let ecef_vec = ned.ecef_vector_at(&ref_pos);
println!("ECEF vector: ({:.2}, {:.2}, {:.2})", ecef_vec.x(), ecef_vec.y(), ecef_vec.z());

// Access components
println!("N: {} E: {} D: {}", ned.n(), ned.e(), ned.d());
```

--------------------------------

### Build NMEA GGA Sentences with Builder Pattern

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Constructs NMEA 0183 GGA sentences using a builder pattern. In `strict` mode, the sentence is capped at 82 characters by dynamically reducing coordinate decimal precision. Non-strict mode allows up to 88 characters.

```rust
use swiftnav::nmea::{GGA, GPSQuality, Source};
use swiftnav::coords::LLHDegrees;
use chrono::Utc;
use std::time::Duration;

// Minimal GGA sentence
let gga = GGA::builder()
    .llh(LLHDegrees::new(37.7749, -122.4194, 10.0))
    .gps_quality(GPSQuality::RTK)
    .sat_in_use(Some(12))
    .hdop(Some(0.9))
    .geoidal_separation(Some(-28.5))
    .build();

let sentence = gga.to_sentence();
println!("{}", sentence);
// $GPGGA,hhmmss.ss,3746.4940,N,12225.1640,W,4,12,0.9,0.0,M,-28.5,M,,*XX\r\n

assert!(sentence.starts_with("$GPGGA") || sentence.starts_with("$GNGGA"));
assert!(sentence.ends_with("\r\n"));

// Strict mode: sentence guaranteed ≤ 82 chars
let strict_gga = GGA {
    source: Source::default(),
    time: Utc::now(),
    llh: LLHDegrees::new(37.7749, -122.4194, 10.0),
    gps_quality: GPSQuality::SPS,
    sat_in_use: Some(8),
    hdop: Some(1.2),
    geoidal_separation: Some(-28.5),
    age_dgps: Some(Duration::from_secs_f64(2.5)),
    reference_station_id: Some(42),
    strict: true,
};
let s = strict_gga.to_sentence();
assert!(s.len() <= 82, "Length {} > 82", s.len());

// Non-strict: up to 88 chars, 7 decimal places of precision (~1.8mm)
let non_strict_gga = GGA { strict: false, ..strict_gga.clone() };
let s2 = non_strict_gga.to_sentence();
assert!(s2.len() <= 88);

```

--------------------------------

### Helmert Datum Transformations with TransformationRepository

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Manages 15-parameter time-dependent Helmert transformations between geodetic reference frames. Supports built-in ITRF, ETRF, NAD83, and WGS84 series transformations and uses BFS for chaining transformations when no direct path exists. Custom transformations can also be added.

```rust
use swiftnav::coords::Coordinate;
use swiftnav::reference_frame::{ReferenceFrame, TransformationRepository};
use swiftnav::time::UtcTime;
use swiftnav::coords::ECEF;

// Load built-in transformations
let repo = TransformationRepository::from_builtin();
println!("Transformation count: {}", repo.count());

let epoch = UtcTime::from_parts(2020, 6, 1, 0, 0, 0.0).to_gps_hardcoded();

// Transform ITRF2014 → NAD83(2011) with velocity
let itrf_coord = Coordinate::with_velocity(
    ReferenceFrame::ITRF2014,
    ECEF::new(-2_703_764.0, -4_261_273.0, 3_887_158.0),
    ECEF::new(-0.0210, 0.0150, 0.0090), // m/year
    epoch,
);

let nad83_coord = repo
    .transform(&itrf_coord, &ReferenceFrame::NAD83_2011)
    .expect("transformation must exist");
println!("NAD83 X: {:.3}", nad83_coord.position().x());
println!("Frame: {}", nad83_coord.reference_frame()); // NAD83(2011)

// Multi-hop: ITRF2020 → ETRF2000 (no direct transform, BFS chains via ITRF2014)
let itrf2020_coord = Coordinate::without_velocity(
    ReferenceFrame::ITRF2020,
    ECEF::new(-2_703_764.0, -4_261_273.0, 3_887_158.0),
    epoch,
);
let etrf_coord = repo
    .transform(&itrf2020_coord, &ReferenceFrame::ETRF2000)
    .expect("path found via BFS");

// Parse reference frames from strings
let frame: ReferenceFrame = "ITRF2014".parse().unwrap();
let nad83: ReferenceFrame = "NAD83(2011)".parse().unwrap();
let custom: ReferenceFrame = "MY_SITE_FRAME".parse().unwrap();

// Add a custom transformation
use swiftnav::reference_frame::Transformation;
use swiftnav::reference_frame::TimeDependentHelmertParams;
let mut custom_repo = TransformationRepository::new();
custom_repo.add_transformation(Transformation {
    from: ReferenceFrame::ITRF2020,
    to: custom.clone(),
    params: TimeDependentHelmertParams {
        epoch: 2020.0,
        ..TimeDependentHelmertParams::zeros()
    },
});
println!("Custom repo count: {}", custom_repo.count()); // 2 (forward + inverse)

```

--------------------------------

### Create and Adjust Coordinate with Velocity

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Creates a Coordinate with an ECEF position, velocity, reference frame, and epoch. Supports advancing the position to a new epoch using the velocity term.

```rust
use swiftnav::coords::{Coordinate, ECEF};
use swiftnav::reference_frame::ReferenceFrame;
use swiftnav::time::UtcTime;

let epoch = UtcTime::from_parts(2020, 1, 1, 0, 0, 0.0).to_gps_hardcoded();

// Create with velocity
let coord = Coordinate::with_velocity(
    ReferenceFrame::ITRF2020,
    ECEF::new(-2_711_206.2, -4_260_069.0, 3_886_079.7),
    ECEF::new(-0.021, 0.015, 0.009), // m/year
    epoch,
);

// Advance position by one year using velocity
let new_epoch = UtcTime::from_parts(2021, 1, 1, 0, 0, 0.0).to_gps_hardcoded();
let updated = coord.adjust_epoch(&new_epoch);
println!("New X: {:.3}", updated.position().x()); // advanced by ~-0.021

// Without velocity
let static_coord = Coordinate::without_velocity(
    ReferenceFrame::ITRF2014,
    ECEF::new(0.0, 0.0, 0.0),
    epoch,
);
println!("Frame: {}", static_coord.reference_frame()); // ITRF2014
```

--------------------------------

### TransformationRepository and ReferenceFrame

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Manages 15-parameter time-dependent Helmert transformations between geodetic reference frames. It supports built-in transformations and chaining via BFS for indirect paths. Custom transformations can also be added.

```APIDOC
## TransformationRepository and ReferenceFrame

### Description
Manages 15-parameter time-dependent Helmert transformations between geodetic reference frames. It includes all built-in ITRF, ETRF, NAD83, and WGS84 series transformations and uses BFS path-finding to chain transformations when no direct path exists.

### Usage
```rust
use swiftnav::{
    coords::{Coordinate, ECEF},
    reference_frame::{TransformationRepository, ReferenceFrame, Transformation, TimeDependentHelmertParams},
    time::UtcTime,
};
use std::str::FromStr;

// Load built-in transformations
let repo = TransformationRepository::from_builtin();
println!("Transformation count: {}", repo.count());

let epoch = UtcTime::from_parts(2020, 6, 1, 0, 0, 0.0).to_gps_hardcoded();

// Transform ITRF2014 → NAD83(2011) with velocity
let itrf_coord = Coordinate::with_velocity(
    ReferenceFrame::ITRF2014,
    ECEF::new(-2_703_764.0, -4_261_273.0, 3_887_158.0),
    ECEF::new(-0.0210, 0.0150, 0.0090), // m/year
    epoch,
);

let nad83_coord = repo
    .transform(&itrf_coord, &ReferenceFrame::NAD83_2011)
    .expect("transformation must exist");
println!("NAD83 X: {:.3}", nad83_coord.position().x());
println!("Frame: {}", nad83_coord.reference_frame()); // NAD83(2011)

// Multi-hop: ITRF2020 → ETRF2000 (no direct transform, BFS chains via ITRF2014)
let itrf2020_coord = Coordinate::without_velocity(
    ReferenceFrame::ITRF2020,
    ECEF::new(-2_703_764.0, -4_261_273.0, 3_887_158.0),
    epoch,
);
let etrf_coord = repo
    .transform(&itrf2020_coord, &ReferenceFrame::ETRF2000)
    .expect("path found via BFS");

// Parse reference frames from strings
let frame: ReferenceFrame = "ITRF2014".parse().unwrap();
let nad83: ReferenceFrame = "NAD83(2011)".parse().unwrap();
let custom: ReferenceFrame = "MY_SITE_FRAME".parse().unwrap();

// Add a custom transformation
let mut custom_repo = TransformationRepository::new();
custom_repo.add_transformation(Transformation {
    from: ReferenceFrame::ITRF2020,
    to: custom.clone(),
    params: TimeDependentHelmertParams {
        epoch: 2020.0,
        ..TimeDependentHelmertParams::zeros()
    },
});
println!("Custom repo count: {}", custom_repo.count()); // 2 (forward + inverse)
```
```

--------------------------------

### Coordinate

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Bundles an ECEF position with optional velocity, a ReferenceFrame, and a GpsTime epoch. Supports epoch adjustment using the velocity term.

```APIDOC
## Coordinate

### Description
Stores a position with reference frame and epoch. It bundles an `ECEF` position with an optional velocity, a `ReferenceFrame`, and a `GpsTime` epoch. It supports epoch adjustment using the velocity term.

### Usage Example
```rust
use swiftnav::coords::{Coordinate, ECEF};
use swiftnav::reference_frame::ReferenceFrame;
use swiftnav::time::UtcTime;

let epoch = UtcTime::from_parts(2020, 1, 1, 0, 0, 0.0).to_gps_hardcoded();

// Create with velocity
let coord = Coordinate::with_velocity(
    ReferenceFrame::ITRF2020,
    ECEF::new(-2_711_206.2, -4_260_069.0, 3_886_079.7),
    ECEF::new(-0.021, 0.015, 0.009), // m/year
    epoch,
);

// Advance position by one year using velocity
let new_epoch = UtcTime::from_parts(2021, 1, 1, 0, 0, 0.0).to_gps_hardcoded();
let updated = coord.adjust_epoch(&new_epoch);
println!("New X: {:.3}", updated.position().x()); // advanced by ~-0.021

// Without velocity
let static_coord = Coordinate::without_velocity(
    ReferenceFrame::ITRF2014,
    ECEF::new(0.0, 0.0, 0.0),
    epoch,
);
println!("Frame: {}", static_coord.reference_frame()); // ITRF2014
```
```

--------------------------------

### GalTime / BdsTime

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Represents Galileo and BeiDou time, similar to GpsTime, with conversions to/from GpsTime.

```APIDOC
## GalTime / BdsTime

### Description
Galileo time and BeiDou time are represented similarly to GPS time and convert to/from `GpsTime`.

### Usage Example
```rust
use swiftnav::time::{GpsTime, GalTime, BdsTime, GAL_TIME_START, BDS_TIME_START};

// GPS → Galileo
let gps = GpsTime::new(1500, 0.0).unwrap();
let gal = gps.to_gal();
println!("GAL WN: {}", gal.wn()); // GPS wn minus Galileo week offset

// GPS → BeiDou
let bds = gps.to_bds();
println!("BDS WN: {}, TOW: {:.3}", bds.wn(), bds.tow());

// Round-trip
let gps_back: GpsTime = gal.to_gps();
println!("Round-trip diff: {}", gps.diff(&gps_back)); // ~0.0

// Start epochs
println!("GAL starts at GPS WN: {}", GAL_TIME_START.wn());
println!("BDS starts at GPS WN: {}", BDS_TIME_START.wn());
```
```

--------------------------------

### Compute CRC-24Q checksum in Rust

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Calculates the Qualcomm 24-bit CRC checksum used in RTCM messages. Supports both full message computation and incremental calculation for streaming data. The function can also be used for verification by checking if the CRC of data appended with its checksum results in zero.

```rust
use swiftnav::edc::compute_crc24q;

// Full message CRC in one call
let msg = vec![
    0xD3, 0x00, 0x13, 0x3E, 0xD7, 0xD3, 0x02, 0x02, 0x98,
    0x0E, 0xDE, 0xEF, 0x34, 0xB4, 0xBD, 0x62, 0xAC, 0x09,
    0x41, 0x98, 0x6F, 0x33,
];
let crc = compute_crc24q(&msg, 0);
assert_eq!(crc, 0x00360B98);
println!("CRC: 0x{:06X}", crc); // 0x360B98

// Incremental computation (streaming data)
let block1 = &msg[..10];
let block2 = &msg[10..];
let partial = compute_crc24q(block1, 0);
let final_crc = compute_crc24q(block2, partial);
assert_eq!(final_crc, 0x00360B98);

// Verification: append CRC bytes to data, re-check should yield 0
let mut data_with_crc = msg.clone();
data_with_crc.push((crc >> 16) as u8);
data_with_crc.push((crc >> 8) as u8);
data_with_crc.push(crc as u8);
let verification = compute_crc24q(&data_with_crc, 0);
assert_eq!(verification, 0, "CRC verification failed: 0x{:06X}", verification);

// Known test vector from crcmod
let test_data = b"123456789";
let crc2 = compute_crc24q(test_data, 0x00B704CE);
assert_eq!(crc2, 0x0021CF02);

```

--------------------------------

### GGA - GPS Fix Data sentence builder

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Constructs NMEA 0183 GGA sentences using a builder pattern. In `strict` mode, the sentence is capped at 82 characters by dynamically reducing coordinate decimal precision.

```APIDOC
## GGA — GPS Fix Data sentence builder

### Description
`GGA` constructs NMEA 0183 GGA sentences using a builder pattern. In `strict` mode the sentence is capped at 82 characters by dynamically reducing coordinate decimal precision.

### Usage
```rust
use swiftnav::nmea::{GGA, GPSQuality, Source};
use swiftnav::coords::LLHDegrees;
use chrono::Utc;
use std::time::Duration;

// Minimal GGA sentence
let gga = GGA::builder()
    .llh(LLHDegrees::new(37.7749, -122.4194, 10.0))
    .gps_quality(GPSQuality::RTK)
    .sat_in_use(Some(12))
    .hdop(Some(0.9))
    .geoidal_separation(Some(-28.5))
    .build();

let sentence = gga.to_sentence();
println!("{}", sentence);
// $GPGGA,hhmmss.ss,3746.4940,N,12225.1640,W,4,12,0.9,0.0,M,-28.5,M,,*XX\r\n

assert!(sentence.starts_with("$GPGGA") || sentence.starts_with("$GNGGA"));
assert!(sentence.ends_with("\r\n"));

// Strict mode: sentence guaranteed ≤ 82 chars
let strict_gga = GGA {
    source: Source::default(),
    time: Utc::now(),
    llh: LLHDegrees::new(37.7749, -122.4194, 10.0),
    gps_quality: GPSQuality::SPS,
    sat_in_use: Some(8),
    hdop: Some(1.2),
    geoidal_separation: Some(-28.5),
    age_dgps: Some(Duration::from_secs_f64(2.5)),
    reference_station_id: Some(42),
    strict: true,
};
let s = strict_gga.to_sentence();
assert!(s.len() <= 82, "Length {} > 82", s.len());

// Non-strict: up to 88 chars, 7 decimal places of precision (~1.8mm)
let non_strict_gga = GGA { strict: false, ..strict_gga.clone() };
let s2 = non_strict_gga.to_sentence();
assert!(s2.len() <= 88);
```
```

--------------------------------

### Calculate Azimuth and Elevation from ECEF Coordinates

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Calculates the azimuth and elevation angles from an observer's ECEF position to a satellite's ECEF position. Requires converting LLHDegrees to ECEF first.

```rust
use swiftnav::coords::{AzimuthElevation, LLHDegrees};

let observer = LLHDegrees::new(37.7749, -122.4194, 10.0).to_ecef();
let satellite = LLHDegrees::new(40.0, -100.0, 20_200_000.0).to_ecef(); // ~GPS orbit

let azel = observer.azel_of(&satellite);
println!("Azimuth:   {:.4} rad ({:.2}°)", azel.az(), azel.az().to_degrees());
println!("Elevation: {:.4} rad ({:.2}°)", azel.el(), azel.el().to_degrees());

// Construct directly
let dir = AzimuthElevation::new(1.5708, 0.5236); // 90° az, 30° el
let [az, el] = *dir.as_array();
```

--------------------------------

### compute_crc24q

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Computes the CRC-24Q checksum, commonly used in RTCM messages. Supports incremental calculation for streaming data.

```APIDOC
## compute_crc24q — Qualcomm 24-bit CRC for RTCM

### Description
Computes the CRC-24Q checksum used in RTCM messages. Supports incremental calculation by chaining calls using the previous CRC as the initial value.

### Function Signature
`fn compute_crc24q(data: &[u8], initial_crc: u32) -> u32`

### Parameters
* **data** (&[u8]) - The byte slice for which to compute the CRC.
* **initial_crc** (u32) - The initial CRC value (0 for a new calculation).

### Returns
* The computed CRC-24Q checksum as a u32.

### Example
```rust
use swiftnav::edc::compute_crc24q;

let msg = vec![0xD3, 0x00, 0x13, 0x3E, 0xD7, 0xD3, 0x02, 0x02, 0x98, 0x0E, 0xDE, 0xEF, 0x34, 0xB4, 0xBD, 0x62, 0xAC, 0x09, 0x41, 0x98, 0x6F, 0x33];
let crc = compute_crc24q(&msg, 0);
assert_eq!(crc, 0x00360B98);

let block1 = &msg[..10];
let block2 = &msg[10..];
let partial = compute_crc24q(block1, 0);
let final_crc = compute_crc24q(block2, partial);
assert_eq!(final_crc, 0x00360B98);

let test_data = b"123456789";
let crc2 = compute_crc24q(test_data, 0x00B704CE);
assert_eq!(crc2, 0x0021CF02);
```
```

--------------------------------

### Calculate NMEA XOR Checksum

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Calculates the NMEA XOR checksum for a given sentence. The checksum is the XOR of all bytes between the '$' and '*' characters (exclusive).

```rust
use swiftnav::nmea::calculate_checksum;

// Checksum is XOR of all bytes between '$' and '*' (exclusive)
let sentence = "$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,," ;
let checksum = calculate_checksum(sentence);
println!("Checksum: {:02X}", checksum);

// Verify a known NMEA sentence
let verified = "$GPGLL,4916.45,N,12311.12,W,225444,A";
let cs = calculate_checksum(verified);
println!("GLL checksum: {:02X}", cs); // 1D

```

--------------------------------

### UtcTime and MJD

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Handles calendar UTC time and Modified Julian Date, with conversions to/from GpsTime.

```APIDOC
## UtcTime and MJD

### Description
`UtcTime` represents calendar UTC time. `MJD` (Modified Julian Date) is a continuous day-based time scale. Both convert to/from `GpsTime`.

### Usage Example
```rust
use swiftnav::time::{UtcTime, MJD};

// Construct UTC from parts
let utc = UtcTime::from_parts(2025, 3, 15, 12, 30, 45.5);
let (y, mo, d, h, mi, s) = utc.to_date();
println!("{y}-{mo:02}-{d:02} {h:02}:{mi:02}:{s:.1}"); // 2025-03-15 12:30:45.5

// UTC → MJD → GPS
let mjd = utc.to_mjd();
println!("MJD: {:.6}", mjd.as_f64());

let gps = mjd.to_gps_hardcoded();
println!("GPS WN: {}, TOW: {:.2}", gps.wn(), gps.tow());

// GPS → UTC round-trip
let utc2 = gps.to_utc_hardcoded();
let mjd2 = utc2.to_mjd();
let diff = (mjd.as_f64() - mjd2.as_f64()).abs();
assert!(diff < 1e-9, "Round-trip error: {diff}");

// MJD from date parts
let mjd3 = MJD::from_parts(2025, 3, 15, 12, 30, 45.5);
println!("MJD: {:.6}", mjd3.as_f64());
```
```

--------------------------------

### GpsTime

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Primary GPS time representation, stored as week number and time-of-week. Supports arithmetic, comparison, and conversions to/from other time scales.

```APIDOC
## GpsTime

### Description
Primary GPS time representation. `GpsTime` is stored as a week number (`wn: i16`) and time-of-week (`tow: f64`, seconds). It supports arithmetic with `std::time::Duration`, comparison, and conversion to/from UTC, Galileo, BeiDou, and MJD.

### Usage Example
```rust
use swiftnav::time::{GpsTime, UtcTime};
use std::time::Duration;

// Create and validate
let t = GpsTime::new(2345, 345_600.0).expect("valid GPS time");
println!("WN: {}, TOW: {}", t.wn(), t.tow()); // WN: 2345, TOW: 345600.0

// Arithmetic
let t2 = t + Duration::from_secs(3600);    // add one hour
let t3 = t - Duration::from_secs(60);      // subtract one minute
println!("Diff: {} s", t2.diff(&t3));       // 3660.0

// Snap to solution epoch (e.g., 10 Hz)
let snapped = t.round_to_epoch(10.0);
let floored = t.floor_to_epoch(10.0);

// Convert to UTC (hardcoded leap seconds)
let utc = t.to_utc_hardcoded();
let (year, month, day, hour, min, sec) = utc.to_date();
println!("{year}-{month:02}-{day:02} {hour:02}:{min:02}:{sec:06.3}");

// Convert from calendar date
let t_from_date = GpsTime::from_parts_hardcoded(2025, 6, 15, 12, 0, 0.0);
println!("WN: {}, TOW: {:.1}", t_from_date.wn(), t_from_date.tow());

// Leap second detection
println!("LSE: {}", t.is_leap_second_event_hardcoded()); // false
```
```

--------------------------------

### AzimuthElevation

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Represents a direction using azimuth and elevation angles in radians. Azimuth ranges from 0 to 2π, and elevation ranges from -π/2 to π/2.

```APIDOC
## AzimuthElevation

### Description
Stores a direction in radians. Azimuth ranges `[0, 2π]` (North = 0, East = π/2). Elevation ranges `[-π/2, π/2]` (Up = π/2).

### Usage Example
```rust
use swiftnav::coords::{AzimuthElevation, LLHDegrees};

let observer = LLHDegrees::new(37.7749, -122.4194, 10.0).to_ecef();
let satellite = LLHDegrees::new(40.0, -100.0, 20_200_000.0).to_ecef(); // ~GPS orbit

let azel = observer.azel_of(&satellite);
println!("Azimuth:   {:.4} rad ({:.2}°)", azel.az(), azel.az().to_degrees());
println!("Elevation: {:.4} rad ({:.2}°)", azel.el(), azel.el().to_degrees());

// Construct directly
let dir = AzimuthElevation::new(1.5708, 0.5236); // 90° az, 30° el
let [az, el] = *dir.as_array();
```
```

--------------------------------

### calculate_checksum — NMEA XOR checksum

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Calculates the NMEA 0183 XOR checksum for a given sentence. The checksum is the XOR of all bytes between the '$' and '*' characters (exclusive).

```APIDOC
## calculate_checksum — NMEA XOR checksum

### Description
Calculates the NMEA XOR checksum for a given sentence. The checksum is the XOR of all bytes between the '$' and '*' characters (exclusive).

### Usage
```rust
use swiftnav::nmea::calculate_checksum;

// Checksum is XOR of all bytes between '$' and '*' (exclusive)
let sentence = "$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,";
let checksum = calculate_checksum(sentence);
println!("Checksum: {:02X}", checksum);

// Verify a known NMEA sentence
let verified = "$GPGLL,4916.45,N,12311.12,W,225444,A";
let cs = calculate_checksum(verified);
println!("GLL checksum: {:02X}", cs); // 1D
```
```

--------------------------------

### GnssSignal

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Represents a unique GNSS signal identified by a satellite Pseudo-Random Noise (PRN) and a code. It provides methods to inspect signal properties and frequencies.

```APIDOC
## GnssSignal — Satellite + code pair

### Description
`GnssSignal` uniquely identifies a signal as a `(satellite PRN, Code)` pair. Construction validates the PRN is in the valid range for its constellation.

### Methods
* `new(prn: u16, code: Code) -> Result<Self, Error>`: Creates a new `GnssSignal`.
* `to_constellation() -> Constellation`: Returns the constellation of the signal.
* `get_carrier_frequency() -> f64`: Returns the carrier frequency of the signal.
* `get_glo_channel_frequency(channel: i8) -> f64`: Returns the GLONASS channel frequency for a given channel number.

### Example
```rust
use swiftnav::signal::{GnssSignal, Code, Constellation};
use std::str::FromStr;

let sig = GnssSignal::new(22, Code::GpsL1ca).expect("valid PRN for GPS");
println!("{}", sig);
println!("{:?}", sig.to_constellation());
println!("Freq: {} Hz", sig.get_carrier_frequency());

let glo = GnssSignal::new(5, Code::GloL1of).unwrap();
let ch_freq = glo.get_glo_channel_frequency(3);
println!("GLO ch3 L1: {} Hz", ch_freq);

let bad = GnssSignal::new(99, Code::GpsL1ca);
assert!(bad.is_err());
```
```

```APIDOC
## Constellation — GNSS Constellation Information

### Description
Provides information about different GNSS constellations, such as the number of satellites.

### Methods
* `sat_count() -> u8`: Returns the number of satellites for the constellation.

### Example
```rust
use swiftnav::signal::Constellation;

println!("GPS sats: {}", Constellation::Gps.sat_count());
println!("GAL sats: {}", Constellation::Gal.sat_count());
println!("BDS sats: {}", Constellation::Bds.sat_count());
```
```

```APIDOC
## Code — GNSS Signal Code Type

### Description
Represents the different signal codes used by GNSS systems. Supports parsing from string and retrieving carrier frequencies.

### Methods
* `from_str(s: &str) -> Result<Self, Error>`: Parses a `Code` from its string representation.
* `get_carrier_frequency() -> f64`: Returns the carrier frequency for the code.

### Example
```rust
use swiftnav::signal::Code;
use std::str::FromStr;

let code = Code::from_str("BDS3 B1C").unwrap();
println!("Freq: {:.2e} Hz", code.get_carrier_frequency());
```
```

--------------------------------

### Check if a year is a leap year in Rust

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Uses the `is_leap_year` function to determine if a given year is a leap year according to the Gregorian calendar rules. Supports both direct checks and iteration over a range of years.

```rust
use swiftnav::time::is_leap_year;

assert!(is_leap_year(2000));   // divisible by 400
assert!(is_leap_year(2024));   // divisible by 4, not 100
assert!(!is_leap_year(1900));  // divisible by 100, not 400
assert!(!is_leap_year(2023));  // not divisible by 4

for year in [2024u16, 2028, 2032] {
    println!("{year} is leap: {}", is_leap_year(year));
}
```

--------------------------------

### is_leap_year

Source: https://context7.com/swift-nav/swiftnav-rs/llms.txt

Checks if a given year is a Gregorian leap year. This function is useful for date and time calculations where leap year rules need to be applied.

```APIDOC
## is_leap_year

### Description
Checks if a given year is a Gregorian leap year.

### Function Signature
`fn is_leap_year(year: u16) -> bool`

### Parameters
* **year** (u16) - The year to check.

### Returns
* `true` if the year is a leap year, `false` otherwise.

### Example
```rust
use swiftnav::time::is_leap_year;

assert!(is_leap_year(2000));
assert!(is_leap_year(2024));
assert!(!is_leap_year(1900));
assert!(!is_leap_year(2023));
```
```
Tokens:
Raw