rotation_construction.rs - source
Description: Source of the Rust file `/Users/erlendbasso/.cargo/registry/src/github.com-1ecc6299db9ec823/nalgebra-0.32.1/src/geometry/rotation_construction.rs`.
Keywords: rust, rustlang, rust-lang

    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

    use num::{One, Zero};

    use simba::scalar::{ClosedAdd, ClosedMul, SupersetOf};

    use crate::base::{SMatrix, Scalar};

    use crate::geometry::Rotation;

    impl<T, const D: usize> Default for Rotation<T, D>
    where
        T: Scalar + Zero + One,
    {
        fn default() -> Self {
            Self::identity()
        }
    }

    /// # Identity
    impl<T, const D: usize> Rotation<T, D>
    where
        T: Scalar + Zero + One,
    {
        /// Creates a new square identity rotation of the given `dimension`.
        ///
        /// # Example
        /// ```
        /// # use nalgebra::{Rotation2, Rotation3};
        /// # use nalgebra::Vector3;
        /// let rot1 = Rotation2::identity();
        /// let rot2 = Rotation2::new(std::f32::consts::FRAC_PI_2);
        ///
        /// assert_eq!(rot1 * rot2, rot2);
        /// assert_eq!(rot2 * rot1, rot2);
        ///
        /// let rot1 = Rotation3::identity();
        /// let rot2 = Rotation3::from_axis_angle(&Vector3::z_axis(), std::f32::consts::FRAC_PI_2);
        ///
        /// assert_eq!(rot1 * rot2, rot2);
        /// assert_eq!(rot2 * rot1, rot2);
        /// ```
        #[inline]
        pub fn identity() -> Rotation<T, D> {
            Self::from_matrix_unchecked(SMatrix::<T, D, D>::identity())
        }
    }

    impl<T: Scalar, const D: usize> Rotation<T, D> {
        /// Cast the components of `self` to another type.
        ///
        /// # Example
        /// ```
        /// # use nalgebra::Rotation2;
        /// let rot = Rotation2::<f64>::identity();
        /// let rot2 = rot.cast::<f32>();
        /// assert_eq!(rot2, Rotation2::<f32>::identity());
        /// ```
        pub fn cast<To: Scalar>(self) -> Rotation<To, D>
        where
            Rotation<To, D>: SupersetOf<Self>,
        {
            crate::convert(self)
        }
    }

    impl<T, const D: usize> One for Rotation<T, D>
    where
        T: Scalar + Zero + One + ClosedAdd + ClosedMul,
    {
        #[inline]
        fn one() -> Self {
            Self::identity()
        }
    }