Small improvements (#74)

I noticed that this repository uses multiple symbols to signify degree
signs in its code, documentation, and outputs:

* A few places used `U+00B0` ° DEGREE SIGN, which is the correct symbol.
* In many other places, `U+00BA` º MASCULINE ORDINAL INDICATOR was in
  use, which is visually similar, but semantically wrong and lead to
  some screen readers pronouncing angles weirdly.

This change replaces the ordinal indicators with degree signs.
Apologies, if this is too pedantic.

Author: esclear

CHANGELOG.md

@@ -74,7 +74,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-- Uphold bearing azimuth guarantee for 90º elevation in ENU
+- Uphold bearing azimuth guarantee for 90° elevation in ENU
   ([#34](https://github.com/helsing-ai/sguaba/pull/34)).
 
 ## [0.9.4]

README.md

@@ -65,7 +65,7 @@ how far North, East, and Down (towards Earth's core) they are relative
 to the observer. [FRD], meanwhile, is a "body frame", and just describes
 positions relative to the observer's concept of Forward (eg, the
 direction pointing in the same direction as the nose of a plane), Right
-(eg, the direction 90º to the right when viewing along Forward), and
+(eg, the direction 90° to the right when viewing along Forward), and
 Down (eg, down through the belly of the plane). Converting between [FRD]
 and [NED] usually requires knowing the orientation of the observer
 relative to North, East, and Down, and converting between [NED] and
@@ -107,15 +107,15 @@ let observation = Coordinate::<PlaneFrd>::from_bearing(
         .azimuth(Angle::new::<degree>(20.))
         // upwards from straight-ahead
         .elevation(Angle::new::<degree>(10.))
-        .expect("elevation is in [-90º, 90º]")
+        .expect("elevation is in [-90°, 90°]")
         .build(),
     Length::new::<meter>(400.), // at this range
 );
 
 // where the plane was at the time (eg, from GPS):
 let wgs84 = Wgs84::builder()
     .latitude(Angle::new::<degree>(12.))
-    .expect("latitude is in [-90º, 90º]")
+    .expect("latitude is in [-90°, 90°]")
     .longitude(Angle::new::<degree>(30.))
     .altitude(Length::new::<meter>(1000.))
     .build();

examples/pilot-as-engineer.rs

@@ -24,15 +24,15 @@ fn main() {
             .azimuth(Angle::new::<degree>(20.))
             // upwards from straight-ahead
             .elevation(Angle::new::<degree>(10.))
-            .expect("elevation is in [-90º, 90º]")
+            .expect("elevation is in [-90°, 90°]")
             .build(),
         Length::new::<meter>(400.), // at this range
     );
 
     // where the plane was at the time (eg, from GPS):
     let wgs84 = Wgs84::builder()
         .latitude(Angle::new::<degree>(12.))
-        .expect("latitude is in [-90º, 90º]")
+        .expect("latitude is in [-90°, 90°]")
         .longitude(Angle::new::<degree>(30.))
         .altitude(Length::new::<meter>(1000.))
         .build();

examples/pilot-as-mathematician.rs

@@ -28,15 +28,15 @@ fn main() {
             .azimuth(Angle::new::<degree>(20.))
             // upwards from straight-ahead
             .elevation(Angle::new::<degree>(10.))
-            .expect("elevation is in [-90º, 90º]")
+            .expect("elevation is in [-90°, 90°]")
             .build(),
         Length::new::<meter>(400.), // at this range
     );
 
     // where the plane was at the time (eg, from GPS):
     let wgs84 = Wgs84::builder()
         .latitude(Angle::new::<degree>(12.))
-        .expect("latitude is in [-90º, 90º]")
+        .expect("latitude is in [-90°, 90°]")
         .longitude(Angle::new::<degree>(30.))
         .altitude(Length::new::<meter>(1000.))
         .build();

examples/target-aquisition-and-confirmation.rs

@@ -29,21 +29,21 @@ fn main() {
     let plane_bearing: Bearing<PlaneNed> = Bearing::builder()
         .azimuth(Angle::new::<degree>(204.74)) // clockwise from North
         .elevation(Angle::new::<degree>(0.)) // level with the horizon
-        .expect("elevation is in [-90º, 90º]")
+        .expect("elevation is in [-90°, 90°]")
         .build();
 
     // Values from the pilot's range finder, manually picked to align with the actual target position (see bottom).
     let target_range = Length::new::<meter>(14824.);
     let target_bearing: Bearing<PlaneFrd> = Bearing::builder()
         .azimuth(Angle::new::<degree>(10.)) // clockwise from forward
         .elevation(Angle::new::<degree>(5.342)) // above nose
-        .expect("elevation is in [-90º, 90º]")
+        .expect("elevation is in [-90°, 90°]")
         .build();
 
     // Value from the ground control's known location
     let ground_control_wgs84 = Wgs84::builder()
         .latitude(Angle::new::<degree>(33.6954))
-        .expect("latitude is in [-90º, 90º]")
+        .expect("latitude is in [-90°, 90°]")
         .longitude(Angle::new::<degree>(-78.8802))
         .altitude(Length::new::<meter>(3.))
         .build();
@@ -54,7 +54,7 @@ fn main() {
         Bearing::builder()
             .azimuth(Angle::new::<degree>(84.574)) // clockwise from North
             .elevation(Angle::new::<degree>(52.582)) // above the horizon
-            .expect("elevation is in [-90º, 90º]")
+            .expect("elevation is in [-90°, 90°]")
             .build(),
         Length::new::<meter>(22236.3), // distance to plane
     );
@@ -139,15 +139,15 @@ fn main() {
     // Sanity checking example against expected coordinates and manually calculated values
     let expected_plane_wgs84 = Wgs84::builder()
         .latitude(Angle::new::<degree>(33.7068))
-        .expect("latitude is in [-90º, 90º]")
+        .expect("latitude is in [-90°, 90°]")
         .longitude(Angle::new::<degree>(-78.7355))
         .altitude(Length::new::<meter>(17678.))
         .build();
     let expected_plane_ecef = Coordinate::<Ecef>::from_wgs84(&expected_plane_wgs84);
 
     let expected_target_wgs84 = Wgs84::builder()
         .latitude(Angle::new::<degree>(33.597744245441966))
-        .expect("latitude is in [-90º, 90º]")
+        .expect("latitude is in [-90°, 90°]")
         .longitude(Angle::new::<degree>(-78.82584635802755))
         .altitude(Length::new::<meter>(19075.36499))
         .build();
@@ -158,7 +158,7 @@ fn main() {
     let expected_ground_bearing_to_target = Bearing::<GroundEnu>::builder()
         .azimuth(Angle::new::<degree>(155.02306))
         .elevation(Angle::new::<degree>(57.84293))
-        .expect("elevation is in [-90º, 90º]")
+        .expect("elevation is in [-90°, 90°]")
         .build();
 
     println!(

src/directions.rs

@@ -45,7 +45,7 @@ use uom::ConstZero;
 ///     .azimuth(Angle::new::<degree>(20.))
 ///     // upwards from straight-ahead
 ///     .elevation(Angle::new::<degree>(10.))
-///     .expect("elevation is in [-90º, 90º]")
+///     .expect("elevation is in [-90°, 90°]")
 ///     .build();
 /// ```
 ///
@@ -61,7 +61,7 @@ use uom::ConstZero;
 ///   azimuth: Angle::new::<degree>(20.),
 ///   // upwards from straight-ahead
 ///   elevation: Angle::new::<degree>(10.),
-/// }).expect("elevation is in [-90º, 90º]");
+/// }).expect("elevation is in [-90°, 90°]");
 /// ```
 ///
 /// [bearing]: https://en.wikipedia.org/wiki/Bearing_%28navigation%29
@@ -506,10 +506,10 @@ mod tests {
 
         // Test with radians at boundaries
         use std::f64::consts::FRAC_PI_2;
-        let bearing7 = bearing!(azimuth = rad(0.0), elevation = rad(1.5707963267948966); in Frd);
+        let bearing7 = bearing!(azimuth = rad(0.0), elevation = rad(FRAC_PI_2); in Frd);
         assert_relative_eq!(bearing7.elevation().get::<radian>(), FRAC_PI_2);
 
-        let bearing8 = bearing!(azimuth = rad(0.0), elevation = rad(-1.5707963267948966); in Frd);
+        let bearing8 = bearing!(azimuth = rad(0.0), elevation = rad(-FRAC_PI_2); in Frd);
         assert_relative_eq!(bearing8.elevation().get::<radian>(), -FRAC_PI_2);
     }
 

src/geodetic.rs

@@ -814,14 +814,14 @@ mod tests {
         // Test with radians at boundaries
         use std::f64::consts::FRAC_PI_2;
         let location7 = wgs84!(
-            latitude = rad(1.5707963267948966),
+            latitude = rad(FRAC_PI_2),
             longitude = rad(0.0),
             altitude = m(0.0)
         );
         assert_relative_eq!(location7.latitude().get::<radian>(), FRAC_PI_2);
 
         let location8 = wgs84!(
-            latitude = rad(-1.5707963267948966),
+            latitude = rad(-FRAC_PI_2),
             longitude = rad(0.0),
             altitude = m(0.0)
         );
@@ -975,7 +975,7 @@ mod tests {
 
     #[test]
     #[should_panic(expected = "conversion from ECEF to WGS84 outside altitude range")]
-    fn wgs_ecef_conversion_fails_for_ecef_origin() -> () {
+    fn wgs_ecef_conversion_fails_for_ecef_origin() {
         let _should_panic = Coordinate::<Ecef>::origin().to_wgs84();
     }
 

src/lib.rs

@@ -45,7 +45,7 @@
 //! or East, North, and Up (for ENU) they are relative to the observer. [FRD], meanwhile, is a
 //! "body frame", and just describes positions relative to the observer's concept of Forward (eg,
 //! the direction pointing in the same direction as the nose of a plane), Right (eg, the direction
-//! 90º to the right when viewing along Forward), and Down (eg, down through the belly of the
+//! 90° to the right when viewing along Forward), and Down (eg, down through the belly of the
 //! plane). Converting between [FRD] and [NED] or [ENU] usually requires knowing the orientation of
 //! the observer relative to North, East, and Down/Up, and converting between [NED]/[ENU] and
 //! [ECEF] (or [WGS84]) requires also knowing the position of the observer in Earth-bound
@@ -87,7 +87,7 @@
 //! Perhaps surprisingly, this is _also_ the case for non-local frames like ECEF and WGS84. Due to
 //! plate tectonics, a spot measured relative to a point on earth's _surface_ technically "moves"
 //! over time. Consider, for example, the Eiffel tower, which is located at
-//! 48.85851298170608ºN, 2.2944746521697468ºE (according to Google Maps at least). Since the
+//! 48.85851298170608°N, 2.2944746521697468°E (according to Google Maps at least). Since the
 //! Eurasian plate drifts over time, if you measured its location a millennium from now, it would
 //! technically be at a different place relative to, say, the Statue of Liberty. So, how does that
 //! affect its latitude and longitude? The answer is that "it depends". There isn't really just

src/math.rs

@@ -1577,9 +1577,7 @@ mod tests {
     use crate::math::{RigidBodyTransform, Rotation};
     use crate::util::BoundedAngle;
     use crate::vectors::Vector;
-    use crate::{coordinate, Point3};
-    use crate::{system, Bearing};
-    use crate::{vector, Vector3};
+    use crate::{coordinate, vector, Bearing, Point3, Vector3};
     use approx::assert_abs_diff_eq;
     use approx::assert_relative_eq;
     use rstest::rstest;

src/vectors.rs

@@ -791,7 +791,7 @@ where
     ///
     /// Since vectors do not include roll information, the desired roll must be passed in. It's
     /// worth reading the documentation on [`Orientation`] for a reminder about the meaning of roll
-    /// here. Very briefly, it is intrinsic, and 0º roll means the object's positive Z axis is
+    /// here. Very briefly, it is intrinsic, and 0° roll means the object's positive Z axis is
     /// aligned with `In`'s positive Z axis.
     ///
     /// Returns `None` if the vector has zero length, as the yaw is then ill-defined.
@@ -800,7 +800,7 @@ where
     #[must_use]
     pub fn orientation_at_origin(&self, roll: impl Into<Angle>) -> Option<Orientation<In>> {
         // The vector is effectively an axis-angle representation of the Tait-Bryan orientation
-        // we're after (with the angle of rotation being 0º). But, when angle is 0º, the axis-angle
+        // we're after (with the angle of rotation being 0°). But, when angle is 0°, the axis-angle
         // representation ends up being a noop from what I can tell. Instead, we compute this from
         // first principles. Note that we cast to the raw length, but that's okay since we only
         // care about the relative magnitudes for these as we're computing angles.
@@ -814,14 +814,14 @@ where
         }
 
         // Per `Orientation::from_tait_bryan_angles`, yaw is rotation about the Z axis with an
-        // object at 0º yaw facing along the positive X axis. Thus, it is rotation on the XY plane
+        // object at 0° yaw facing along the positive X axis. Thus, it is rotation on the XY plane
         // (and uses only the x and y coordinates). Positive yaw is counter-clockwise rotation
         // about Z (ie, towards +Y from +X), and thus we want the sin of the angle between X and Y
         // with no sign flipping.
         //
         // Also note that atan2 guarantees that it returns 0 if both components are 0.
         let yaw = y.atan2(x);
-        // Pitch is the rotation about the Y axis, with 0º pitch being aligned with the yaw axis
+        // Pitch is the rotation about the Y axis, with 0° pitch being aligned with the yaw axis
         // (since we're using intrinsic rotations). Per the right-hand rule, positive pitch
         // rotates from +X toward -Z, so we negate z to get the correct sign.
         let pitch = (-z).atan2((x.powi(P2::new()) + y.powi(P2::new())).sqrt());
@@ -1445,7 +1445,7 @@ mod tests {
 
         #[test]
         fn orientation_at_origin_positive_x_axis() {
-            // Vector pointing along +X should have yaw=0º, pitch=0º
+            // Vector pointing along +X should have yaw=0°, pitch=0°
             let v = vector!(x = m(1.0), y = m(0.0), z = m(0.0); in TestXyz);
             let orientation = v
                 .orientation_at_origin(Angle::ZERO)
@@ -1459,7 +1459,7 @@ mod tests {
 
         #[test]
         fn orientation_at_origin_positive_y_axis() {
-            // Vector pointing along +Y should have yaw=90º, pitch=0º
+            // Vector pointing along +Y should have yaw=90°, pitch=0°
             let v = vector!(x = m(0.0), y = m(1.0), z = m(0.0); in TestXyz);
             let orientation = v
                 .orientation_at_origin(Angle::ZERO)
@@ -1473,7 +1473,7 @@ mod tests {
 
         #[test]
         fn orientation_at_origin_positive_z_axis() {
-            // Vector pointing along +Z should have yaw=0º (arbitrary), pitch=-90º
+            // Vector pointing along +Z should have yaw=0° (arbitrary), pitch=-90°
             let v = vector!(x = m(0.0), y = m(0.0), z = m(1.0); in TestXyz);
             let orientation = v
                 .orientation_at_origin(Angle::ZERO)
@@ -1487,22 +1487,22 @@ mod tests {
 
         #[test]
         fn orientation_at_origin_negative_x_axis() {
-            // Vector pointing along -X should have yaw=180º or -180º, pitch=0º
+            // Vector pointing along -X should have yaw=180° or -180°, pitch=0°
             let v = vector!(x = m(-1.0), y = m(0.0), z = m(0.0); in TestXyz);
             let orientation = v
                 .orientation_at_origin(Angle::ZERO)
                 .expect("non-zero vector");
             let (yaw, pitch, roll) = orientation.to_tait_bryan_angles();
 
-            // atan2(0, -1) = 180º or -180º depending on convention
+            // atan2(0, -1) = 180° or -180° depending on convention
             assert_abs_diff_eq!(yaw.get::<degree>().abs(), 180.0, epsilon = 1e-10);
             assert_abs_diff_eq!(pitch.get::<degree>(), 0.0, epsilon = 1e-10);
             assert_abs_diff_eq!(roll.get::<degree>(), 0.0, epsilon = 1e-10);
         }
 
         #[test]
         fn orientation_at_origin_45_degree_xy_plane() {
-            // Vector at 45º in XY plane should have yaw=45º, pitch=0º
+            // Vector at 45° in XY plane should have yaw=45°, pitch=0°
             let v = vector!(x = m(1.0), y = m(1.0), z = m(0.0); in TestXyz);
             let orientation = v
                 .orientation_at_origin(Angle::ZERO)
@@ -1516,7 +1516,7 @@ mod tests {
 
         #[test]
         fn orientation_at_origin_45_degree_xz_plane() {
-            // Vector at 45º in XZ plane should have yaw=0º, pitch=-45º
+            // Vector at 45° in XZ plane should have yaw=0°, pitch=-45°
             let v = vector!(x = m(1.0), y = m(0.0), z = m(1.0); in TestXyz);
             let orientation = v
                 .orientation_at_origin(Angle::ZERO)
@@ -1531,8 +1531,8 @@ mod tests {
         #[test]
         fn orientation_at_origin_general_3d_vector() {
             // Vector at (3, 4, 5) - verify the full computation
-            // Expected yaw = atan2(4, 3) ≈ 53.13º
-            // Expected pitch = atan2(-5, sqrt(3² + 4²)) = atan2(-5, 5) = -45º
+            // Expected yaw = atan2(4, 3) ≈ 53.13°
+            // Expected pitch = atan2(-5, sqrt(3² + 4²)) = atan2(-5, 5) = -45°
             let v = vector!(x = m(3.0), y = m(4.0), z = m(5.0); in TestXyz);
             let orientation = v
                 .orientation_at_origin(Angle::ZERO)
@@ -1561,7 +1561,7 @@ mod tests {
             // - positive yaw is from-north-towards-east
             // - positive pitch is towards -Z (as always), so "up"
             //
-            // so a 45º-nose-up east vector should have yaw=90º and pitch=45º
+            // so a 45°-nose-up east vector should have yaw=90° and pitch=45°
             let v = vector!(n = m(0.0), e = m(1.0), d = m(-1.0); in TestNed);
             let orientation = v
                 .orientation_at_origin(Angle::ZERO)
@@ -1582,7 +1582,7 @@ mod tests {
             // - positive yaw is from-east-towards-north
             // - positive pitch is towards -Z (as always), so "down"
             //
-            // so a 45º-nose-up north vector should have yaw=90º and pitch=-45º
+            // so a 45°-nose-up north vector should have yaw=90° and pitch=-45°
             let v = vector!(e = m(0.0), n = m(1.0), u = m(1.0); in TestEnu);
             let orientation = v
                 .orientation_at_origin(Angle::ZERO)