Advanced Dead Reckoning

Accuracy over time:
                                 ×
                              × × ×
                           ×  DR error grows
                        ×
                     ×
                  ×
               ×
            ×
FIX ──→ ⊕──────×──────────×─────────────×──────────────────
        ↑     ↑           ↑             ↑
      Start  10min      30min         60min
        0m   ~100m      ~300m         ~500m+ error

            Wind
              ↓
          ┌───────┐
          │       │
    Course │   ↘   │ Track (actual)
          │    ↘  │
          │     ↘ │ ← Leeway angle (typically 3-7°)
          └───────┘

import math

def dead_reckon(lat, lon, course, distance, unit='nm'):
    """
    Calculate new position from DR.

    Args:
        lat: Starting latitude (decimal degrees, positive = N)
        lon: Starting longitude (decimal degrees, positive = E)
        course: Course in degrees (true)
        distance: Distance traveled
        unit: 'nm' (nautical miles), 'km', or 'm'

    Returns:
        (new_lat, new_lon) in decimal degrees
    """
    # Convert to nautical miles if needed
    if unit == 'km':
        distance = distance / 1.852
    elif unit == 'm':
        distance = distance / 1852

    # Convert to radians
    lat_r = math.radians(lat)
    course_r = math.radians(course)

    # Calculate deltas
    # 1 nautical mile = 1 minute of latitude
    delta_lat = distance * math.cos(course_r) / 60  # degrees

    # Longitude correction for latitude
    delta_lon = (distance * math.sin(course_r)) / (60 * math.cos(lat_r))

    new_lat = lat + delta_lat
    new_lon = lon + delta_lon

    return new_lat, new_lon


def course_made_good(lat1, lon1, lat2, lon2):
    """Calculate course and distance between two points."""

    # Delta in minutes
    delta_lat = (lat2 - lat1) * 60  # nm (approximately)
    delta_lon = (lon2 - lon1) * 60 * math.cos(math.radians((lat1 + lat2) / 2))

    # Distance
    distance = math.sqrt(delta_lat**2 + delta_lon**2)

    # Course (using atan2 for correct quadrant)
    course = math.degrees(math.atan2(delta_lon, delta_lat))
    if course < 0:
        course += 360

    return course, distance


def error_circle_radius(distance, angular_error_deg=3, distance_error_pct=5):
    """
    Calculate position uncertainty radius.

    Args:
        distance: Distance traveled (any unit)
        angular_error_deg: Compass error in degrees
        distance_error_pct: Distance error as percentage

    Returns:
        Radius of uncertainty circle (same unit as distance)
    """
    angular_error_rad = math.radians(angular_error_deg)

    cross_track_error = distance * math.sin(angular_error_rad)
    along_track_error = distance * (distance_error_pct / 100)

    total_error = math.sqrt(cross_track_error**2 + along_track_error**2)

    return total_error


# Example usage
if __name__ == "__main__":
    # Starting position
    start_lat = 34.0
    start_lon = -118.0

    # Multi-leg traverse
    legs = [
        (45, 10, 'nm'),   # Course 045°, 10 nm
        (90, 5, 'nm'),    # Course 090°, 5 nm
        (180, 8, 'nm'),   # Course 180°, 8 nm
    ]

    lat, lon = start_lat, start_lon
    total_dist = 0

    print(f"Start: {lat:.4f}°N, {abs(lon):.4f}°W")

    for course, dist, unit in legs:
        lat, lon = dead_reckon(lat, lon, course, dist, unit)
        total_dist += dist
        print(f"After {course:03d}°/{dist}{unit}: {lat:.4f}°N, {abs(lon):.4f}°W")

    # Course made good
    cmg, dmg = course_made_good(start_lat, start_lon, lat, lon)
    print(f"\nCourse Made Good: {cmg:.1f}°")
    print(f"Distance Made Good: {dmg:.2f} nm")

    # Error estimate
    error = error_circle_radius(total_dist)
    print(f"\nPosition uncertainty: ±{error:.2f} nm ({error * 1.852:.2f} km)")