translation_construction.rs - source
Description: Source of the Rust file `/Users/erlendbasso/.cargo/registry/src/github.com-1ecc6299db9ec823/nalgebra-0.32.1/src/geometry/translation_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
    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
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129

    #[cfg(feature = "arbitrary")]
    use crate::base::storage::Owned;
    #[cfg(feature = "arbitrary")]
    use quickcheck::{Arbitrary, Gen};

    use num::{One, Zero};
    #[cfg(feature = "rand-no-std")]
    use rand::{
        distributions::{Distribution, Standard},
        Rng,
    };

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

    use crate::base::{SVector, Scalar};
    use crate::geometry::Translation;

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

    impl<T: Scalar, const D: usize> Translation<T, D> {
        /// Creates a new identity translation.
        ///
        /// # Example
        /// ```
        /// # use nalgebra::{Point2, Point3, Translation2, Translation3};
        /// let t = Translation2::identity();
        /// let p = Point2::new(1.0, 2.0);
        /// assert_eq!(t * p, p);
        ///
        /// // Works in all dimensions.
        /// let t = Translation3::identity();
        /// let p = Point3::new(1.0, 2.0, 3.0);
        /// assert_eq!(t * p, p);
        /// ```
        #[inline]
        pub fn identity() -> Translation<T, D>
        where
            T: Zero,
        {
            Self::from(SVector::<T, D>::from_element(T::zero()))
        }

        /// Cast the components of `self` to another type.
        ///
        /// # Example
        /// ```
        /// # use nalgebra::Translation2;
        /// let tra = Translation2::new(1.0f64, 2.0);
        /// let tra2 = tra.cast::<f32>();
        /// assert_eq!(tra2, Translation2::new(1.0f32, 2.0));
        /// ```
        pub fn cast<To: Scalar>(self) -> Translation<To, D>
        where
            Translation<To, D>: SupersetOf<Self>,
        {
            crate::convert(self)
        }
    }

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

    #[cfg(feature = "rand-no-std")]
    impl<T: Scalar, const D: usize> Distribution<Translation<T, D>> for Standard
    where
        Standard: Distribution<T>,
    {
        /// Generate an arbitrary random variate for testing purposes.
        #[inline]
        fn sample<G: Rng + ?Sized>(&self, rng: &mut G) -> Translation<T, D> {
            Translation::from(rng.gen::<SVector<T, D>>())
        }
    }

    #[cfg(feature = "arbitrary")]
    impl<T: Scalar + Arbitrary + Send, const D: usize> Arbitrary for Translation<T, D>
    where
        Owned<T, crate::Const<D>>: Send,
    {
        #[inline]
        fn arbitrary(rng: &mut Gen) -> Self {
            let v: SVector<T, D> = Arbitrary::arbitrary(rng);
            Self::from(v)
        }
    }

    /*
     *
     * Small translation construction from components.
     *
     */
    macro_rules! componentwise_constructors_impl(
        ($($doc: expr; $D: expr, $($args: ident:$irow: expr),*);* $(;)*) => {$(
            impl<T> Translation<T, $D>
                 {
                #[doc = "Initializes this translation from its components."]
                #[doc = "# Example\n```"]
                #[doc = $doc]
                #[doc = "```"]
                #[inline]
                pub const fn new($($args: T),*) -> Self {
                    Self { vector: SVector::<T, $D>::new($($args),*) }
                }
            }
        )*}
    );

    componentwise_constructors_impl!(
        "# use nalgebra::Translation1;\nlet t = Translation1::new(1.0);\nassert!(t.vector.x == 1.0);";
        1, x:0;
        "# use nalgebra::Translation2;\nlet t = Translation2::new(1.0, 2.0);\nassert!(t.vector.x == 1.0 && t.vector.y == 2.0);";
        2, x:0, y:1;
        "# use nalgebra::Translation3;\nlet t = Translation3::new(1.0, 2.0, 3.0);\nassert!(t.vector.x == 1.0 && t.vector.y == 2.0 && t.vector.z == 3.0);";
        3, x:0, y:1, z:2;
        "# use nalgebra::Translation4;\nlet t = Translation4::new(1.0, 2.0, 3.0, 4.0);\nassert!(t.vector.x == 1.0 && t.vector.y == 2.0 && t.vector.z == 3.0 && t.vector.w == 4.0);";
        4, x:0, y:1, z:2, w:3;
        "# use nalgebra::Translation5;\nlet t = Translation5::new(1.0, 2.0, 3.0, 4.0, 5.0);\nassert!(t.vector.x == 1.0 && t.vector.y == 2.0 && t.vector.z == 3.0 && t.vector.w == 4.0 && t.vector.a == 5.0);";
        5, x:0, y:1, z:2, w:3, a:4;
        "# use nalgebra::Translation6;\nlet t = Translation6::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0);\nassert!(t.vector.x == 1.0 && t.vector.y == 2.0 && t.vector.z == 3.0 && t.vector.w == 4.0 && t.vector.a == 5.0 && t.vector.b == 6.0);";
        6, x:0, y:1, z:2, w:3, a:4, b:5;
    );