kinavis 1.0.1

A Rust library for solving common maritime navigation tasks.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! Deviation table row.

use crate::angle::{Deviation, MAX_DEVIATION_DEG};
#[cfg(feature = "serde")]
use crate::error::NavigationError;
use crate::error::{ensure_range, Result};

/// Deviation table row.
#[derive(Debug, Clone, Copy, PartialEq)]
#[cfg_attr(
    feature = "serde",
    derive(serde::Serialize, serde::Deserialize),
    serde(try_from = "(i32, f64)", into = "(i32, f64)")
)]
pub struct DeviationNode {
    course: i32,
    deviation: f64,
}

impl DeviationNode {
    /// Compass course, `0..360` degrees.
    #[must_use]
    pub const fn course(&self) -> i32 {
        self.course
    }

    /// Tabulated deviation.
    #[must_use]
    pub fn deviation(&self) -> Deviation {
        // Validated on insertion into the table.
        Deviation::new(self.deviation).unwrap_or(Deviation::ZERO)
    }

    /// Tabulated deviation, degrees.
    #[must_use]
    pub const fn deviation_degrees(&self) -> f64 {
        self.deviation
    }
}

impl DeviationNode {
    /// Node with the course normalised into `0..360`.
    ///
    /// # Errors
    ///
    /// [`KernelError::NotFinite`](crate::KernelError::NotFinite) or
    /// [`KernelError::OutOfRange`](crate::KernelError::OutOfRange) for an
    /// invalid deviation.
    pub(crate) fn new(course: i32, deviation: f64) -> Result<Self> {
        ensure_range(
            "deviation",
            deviation,
            -MAX_DEVIATION_DEG,
            MAX_DEVIATION_DEG,
        )?;
        Ok(Self {
            course: course.rem_euclid(360),
            deviation,
        })
    }

    /// Node from an already validated deviation.
    pub(crate) fn with_deviation(course: i32, deviation: Deviation) -> Self {
        Self {
            course: course.rem_euclid(360),
            deviation: deviation.degrees(),
        }
    }

    /// Zero-deviation node, for initialising a table.
    pub(crate) fn zero_at(course: i32) -> Self {
        Self {
            course: course.rem_euclid(360),
            deviation: 0.0,
        }
    }

    /// Compass course, degrees.
    #[must_use]
    pub fn course_degrees(&self) -> f64 {
        f64::from(self.course)
    }

    /// Overwrites the value; the caller has validated it.
    pub(crate) fn set_deviation_degrees(&mut self, deviation: f64) {
        self.deviation = deviation;
    }
}

#[cfg(feature = "serde")]
impl TryFrom<(i32, f64)> for DeviationNode {
    type Error = NavigationError;

    /// Validated on deserialisation: no invalid deviation or course outside
    /// `0..360`.
    fn try_from((course, deviation): (i32, f64)) -> Result<Self> {
        Self::new(course, deviation)
    }
}

#[cfg(feature = "serde")]
impl From<DeviationNode> for (i32, f64) {
    fn from(node: DeviationNode) -> Self {
        (node.course, node.deviation)
    }
}