      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

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

    use num::{One, Zero};
    use rand::distributions::{Distribution, Standard};
    use rand::Rng;

    use alga::general::ClosedAdd;

    use crate::base::allocator::Allocator;
    use crate::base::dimension::{DimName, U1, U2, U3, U4, U5, U6};
    use crate::base::{DefaultAllocator, Scalar, VectorN};

    use crate::geometry::Translation;

    impl<N: Scalar + Zero, D: DimName> Translation<N, D>
    where DefaultAllocator: Allocator<N, 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<N, D> {
            Self::from(VectorN::<N, D>::from_element(N::zero()))
        }
    }

    impl<N: Scalar + Zero + ClosedAdd, D: DimName> One for Translation<N, D>
    where DefaultAllocator: Allocator<N, D>
    {
        #[inline]
        fn one() -> Self {
            Self::identity()
        }
    }

    impl<N: Scalar, D: DimName> Distribution<Translation<N, D>> for Standard
    where
        DefaultAllocator: Allocator<N, D>,
        Standard: Distribution<N>,
    {
        #[inline]
        fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> Translation<N, D> {
            Translation::from(rng.gen::<VectorN<N, D>>())
        }
    }

    #[cfg(feature = "arbitrary")]
    impl<N: Scalar + Arbitrary, D: DimName> Arbitrary for Translation<N, D>
    where
        DefaultAllocator: Allocator<N, D>,
        Owned<N, D>: Send,
    {
        #[inline]
        fn arbitrary<G: Gen>(rng: &mut G) -> Self {
            let v: VectorN<N, D> = Arbitrary::arbitrary(rng);
            Self::from(v)
        }
    }

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

    componentwise_constructors_impl!(
        "# use nalgebra::Translation1;\nlet t = Translation1::new(1.0);\nassert!(t.vector.x == 1.0);";
        U1, x:0;
        "# use nalgebra::Translation2;\nlet t = Translation2::new(1.0, 2.0);\nassert!(t.vector.x == 1.0 && t.vector.y == 2.0);";
        U2, 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);";
        U3, 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);";
        U4, 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);";
        U5, 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);";
        U6, x:0, y:1, z:2, w:3, a:4, b:5;
    );

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)