nalgebra/tests/core/conversion.rs

#![cfg(all(feature = "proptest-support", feature = "alga"))]
use alga::linear::Transformation;
use na::{
    self, Affine3, Isometry3, Matrix2, Matrix2x3, Matrix2x4, Matrix2x5, Matrix2x6, Matrix3,
    Matrix3x2, Matrix3x4, Matrix3x5, Matrix3x6, Matrix4, Matrix4x2, Matrix4x3, Matrix4x5,
    Matrix4x6, Matrix5, Matrix5x2, Matrix5x3, Matrix5x4, Matrix5x6, Matrix6, Matrix6x2, Matrix6x3,
    Matrix6x4, Matrix6x5, Projective3, Rotation3, RowVector1, RowVector2, RowVector3, RowVector4,
    RowVector5, RowVector6, Similarity3, Transform3, UnitQuaternion, Vector1, Vector2, Vector3,
    Vector4, Vector5, Vector6,
};
use na::{DMatrix, DMatrixSlice, DMatrixSliceMut, MatrixSlice, MatrixSliceMut};
use na::{U1, U3, U4};

use crate::proptest::*;
use proptest::{prop_assert, prop_assert_eq, proptest};

proptest! {
    #[test]
    fn translation_conversion(t in translation3(), v in vector3(), p in point3()) {
        let iso: Isometry3<f64>   = na::convert(t);
        let sim: Similarity3<f64> = na::convert(t);
        let aff: Affine3<f64>     = na::convert(t);
        let prj: Projective3<f64> = na::convert(t);
        let tr:  Transform3<f64>  = na::convert(t);

        prop_assert_eq!(t, na::try_convert(iso).unwrap());
        prop_assert_eq!(t, na::try_convert(sim).unwrap());
        prop_assert_eq!(t, na::try_convert(aff).unwrap());
        prop_assert_eq!(t, na::try_convert(prj).unwrap());
        prop_assert_eq!(t, na::try_convert(tr).unwrap() );

        prop_assert_eq!(t.transform_vector(&v), iso * v);
        prop_assert_eq!(t.transform_vector(&v), sim * v);
        prop_assert_eq!(t.transform_vector(&v), aff * v);
        prop_assert_eq!(t.transform_vector(&v), prj * v);
        prop_assert_eq!(t.transform_vector(&v), tr  * v);

        prop_assert_eq!(t * p, iso * p);
        prop_assert_eq!(t * p, sim * p);
        prop_assert_eq!(t * p, aff * p);
        prop_assert_eq!(t * p, prj * p);
        prop_assert_eq!(t * p, tr  * p);
    }

    #[test]
    fn rotation_conversion(r in rotation3(), v in vector3(), p in point3()) {
        let uq:  UnitQuaternion<f64> = na::convert(r);
        let iso: Isometry3<f64>      = na::convert(r);
        let sim: Similarity3<f64>    = na::convert(r);
        let aff: Affine3<f64>        = na::convert(r);
        let prj: Projective3<f64>    = na::convert(r);
        let tr:  Transform3<f64>     = na::convert(r);

        prop_assert!(relative_eq!(r, na::try_convert(uq).unwrap(),  epsilon = 1.0e-7));
        prop_assert!(relative_eq!(r, na::try_convert(iso).unwrap(), epsilon = 1.0e-7));
        prop_assert!(relative_eq!(r, na::try_convert(sim).unwrap(), epsilon = 1.0e-7));
        prop_assert_eq!(r, na::try_convert(aff).unwrap());
        prop_assert_eq!(r, na::try_convert(prj).unwrap());
        prop_assert_eq!(r, na::try_convert(tr).unwrap() );

        // NOTE: we need relative_eq because Isometry and Similarity use quaternions.
        prop_assert!(relative_eq!(r * v, uq  * v, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(r * v, iso * v, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(r * v, sim * v, epsilon = 1.0e-7));
        prop_assert_eq!(r * v, aff * v);
        prop_assert_eq!(r * v, prj * v);
        prop_assert_eq!(r * v, tr  * v);

        prop_assert!(relative_eq!(r * p, uq  * p, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(r * p, iso * p, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(r * p, sim * p, epsilon = 1.0e-7));
        prop_assert_eq!(r * p, aff * p);
        prop_assert_eq!(r * p, prj * p);
        prop_assert_eq!(r * p, tr  * p);
    }

    #[test]
    fn unit_quaternion_conversion(uq in unit_quaternion(), v in vector3(), p in point3()) {
        let rot: Rotation3<f64>   = na::convert(uq);
        let iso: Isometry3<f64>   = na::convert(uq);
        let sim: Similarity3<f64> = na::convert(uq);
        let aff: Affine3<f64>     = na::convert(uq);
        let prj: Projective3<f64> = na::convert(uq);
        let tr:  Transform3<f64>  = na::convert(uq);

        prop_assert_eq!(uq, na::try_convert(iso).unwrap());
        prop_assert_eq!(uq, na::try_convert(sim).unwrap());
        prop_assert!(relative_eq!(uq, na::try_convert(rot).unwrap(), epsilon = 1.0e-7));
        prop_assert!(relative_eq!(uq, na::try_convert(aff).unwrap(), epsilon = 1.0e-7));
        prop_assert!(relative_eq!(uq, na::try_convert(prj).unwrap(), epsilon = 1.0e-7));
        prop_assert!(relative_eq!(uq, na::try_convert(tr).unwrap(), epsilon = 1.0e-7) );

        // NOTE: iso and sim use unit quaternions for the rotation so conversions to them are exact.
        prop_assert!(relative_eq!(uq * v, rot * v, epsilon = 1.0e-7));
        prop_assert_eq!(uq * v, iso * v);
        prop_assert_eq!(uq * v, sim * v);
        prop_assert!(relative_eq!(uq * v, aff * v, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(uq * v, prj * v, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(uq * v, tr  * v, epsilon = 1.0e-7));

        prop_assert!(relative_eq!(uq * p, rot * p, epsilon = 1.0e-7));
        prop_assert_eq!(uq * p, iso * p);
        prop_assert_eq!(uq * p, sim * p);
        prop_assert!(relative_eq!(uq * p, aff * p, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(uq * p, prj * p, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(uq * p, tr  * p, epsilon = 1.0e-7));
    }

    #[test]
    fn isometry_conversion(iso in isometry3(), v in vector3(), p in point3()) {
        let sim: Similarity3<f64> = na::convert(iso);
        let aff: Affine3<f64>     = na::convert(iso);
        let prj: Projective3<f64> = na::convert(iso);
        let tr:  Transform3<f64>  = na::convert(iso);


        prop_assert_eq!(iso, na::try_convert(sim).unwrap());
        prop_assert!(relative_eq!(iso, na::try_convert(aff).unwrap(), epsilon = 1.0e-7));
        prop_assert!(relative_eq!(iso, na::try_convert(prj).unwrap(), epsilon = 1.0e-7));
        prop_assert!(relative_eq!(iso, na::try_convert(tr).unwrap(), epsilon = 1.0e-7) );

        prop_assert_eq!(iso * v, sim * v);
        prop_assert!(relative_eq!(iso * v, aff * v, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(iso * v, prj * v, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(iso * v, tr  * v, epsilon = 1.0e-7));

        prop_assert_eq!(iso * p, sim * p);
        prop_assert!(relative_eq!(iso * p, aff * p, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(iso * p, prj * p, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(iso * p, tr  * p, epsilon = 1.0e-7));
    }

    #[test]
    fn similarity_conversion(sim in similarity3(), v in vector3(), p in point3()) {
        let aff: Affine3<f64>     = na::convert(sim);
        let prj: Projective3<f64> = na::convert(sim);
        let tr:  Transform3<f64>  = na::convert(sim);

        prop_assert!(relative_eq!(sim, na::try_convert(aff).unwrap(), epsilon = 1.0e-7));
        prop_assert!(relative_eq!(sim, na::try_convert(prj).unwrap(), epsilon = 1.0e-7));
        prop_assert!(relative_eq!(sim, na::try_convert(tr).unwrap(),  epsilon = 1.0e-7));

        prop_assert!(relative_eq!(sim * v, aff * v, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(sim * v, prj * v, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(sim * v, tr  * v, epsilon = 1.0e-7));

        prop_assert!(relative_eq!(sim * p, aff * p, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(sim * p, prj * p, epsilon = 1.0e-7));
        prop_assert!(relative_eq!(sim * p, tr  * p, epsilon = 1.0e-7));
    }

    // XXX test Transform
}

macro_rules! array_vector_conversion(
    ($($array_vector_conversion_i: ident, $Vector: ident, $SZ: expr);* $(;)*) => {$(
        #[test]
        fn $array_vector_conversion_i() {
            let v       = $Vector::from_fn(|i, _| i);
            let arr: [usize; $SZ] = v.into();
            let arr_ref: &[usize; $SZ] = v.as_ref();
            let v2      = $Vector::from(arr);

            for i in 0 .. $SZ {
                assert_eq!(arr[i], i);
                assert_eq!(arr_ref[i], i);
            }

            assert_eq!(v, v2);
        }
    )*}
);

array_vector_conversion!(
    array_vector_conversion_1,  Vector1,  1;
    array_vector_conversion_2,  Vector2,  2;
    array_vector_conversion_3,  Vector3,  3;
    array_vector_conversion_4,  Vector4,  4;
    array_vector_conversion_5,  Vector5,  5;
    array_vector_conversion_6,  Vector6,  6;
);

macro_rules! array_row_vector_conversion(
    ($($array_vector_conversion_i: ident, $Vector: ident, $SZ: expr);* $(;)*) => {$(
        #[test]
        fn $array_vector_conversion_i() {
            let v       = $Vector::from_fn(|_, i| i);
            let arr: [usize; $SZ] = v.into();
            let arr_ref = v.as_ref();
            let v2      = $Vector::from(arr);

            for i in 0 .. $SZ {
                assert_eq!(arr[i], i);
                assert_eq!(arr_ref[i], i);
            }

            assert_eq!(v, v2);
        }
    )*}
);

array_row_vector_conversion!(
    array_row_vector_conversion_1,  RowVector1,  1;
    array_row_vector_conversion_2,  RowVector2,  2;
    array_row_vector_conversion_3,  RowVector3,  3;
    array_row_vector_conversion_4,  RowVector4,  4;
    array_row_vector_conversion_5,  RowVector5,  5;
    array_row_vector_conversion_6,  RowVector6,  6;
);

macro_rules! array_matrix_conversion(
    ($($array_matrix_conversion_i_j: ident, $Matrix: ident, ($NRows: expr, $NCols: expr));* $(;)*) => {$(
        #[test]
        fn $array_matrix_conversion_i_j() {
            let m       = $Matrix::from_fn(|i, j| i * 10 + j);
            let arr: [[usize; $NRows]; $NCols] = m.into();
            let arr_ref = m.as_ref();
            let m2      = $Matrix::from(arr);

            for i in 0 .. $NRows {
                for j in 0 .. $NCols {
                    assert_eq!(arr[j][i], i * 10 + j);
                    assert_eq!(arr_ref[j][i], i * 10 + j);
                }
            }

            assert_eq!(m, m2);
        }
    )*}
);

array_matrix_conversion!(
    array_matrix_conversion_2_2, Matrix2,   (2, 2);
    array_matrix_conversion_2_3, Matrix2x3, (2, 3);
    array_matrix_conversion_2_4, Matrix2x4, (2, 4);
    array_matrix_conversion_2_5, Matrix2x5, (2, 5);
    array_matrix_conversion_2_6, Matrix2x6, (2, 6);

    array_matrix_conversion_3_2, Matrix3x2, (3, 2);
    array_matrix_conversion_3_3, Matrix3,   (3, 3);
    array_matrix_conversion_3_4, Matrix3x4, (3, 4);
    array_matrix_conversion_3_5, Matrix3x5, (3, 5);
    array_matrix_conversion_3_6, Matrix3x6, (3, 6);

    array_matrix_conversion_4_2, Matrix4x2, (4, 2);
    array_matrix_conversion_4_3, Matrix4x3, (4, 3);
    array_matrix_conversion_4_4, Matrix4,   (4, 4);
    array_matrix_conversion_4_5, Matrix4x5, (4, 5);
    array_matrix_conversion_4_6, Matrix4x6, (4, 6);

    array_matrix_conversion_5_2, Matrix5x2, (5, 2);
    array_matrix_conversion_5_3, Matrix5x3, (5, 3);
    array_matrix_conversion_5_4, Matrix5x4, (5, 4);
    array_matrix_conversion_5_5, Matrix5,   (5, 5);
    array_matrix_conversion_5_6, Matrix5x6, (5, 6);

    array_matrix_conversion_6_2, Matrix6x2, (6, 2);
    array_matrix_conversion_6_3, Matrix6x3, (6, 3);
    array_matrix_conversion_6_4, Matrix6x4, (6, 4);
    array_matrix_conversion_6_5, Matrix6x5, (6, 5);
    array_matrix_conversion_6_6, Matrix6,   (6, 6);
);

#[test]
fn matrix_slice_from_matrix_ref() {
    let a = Matrix3x4::new(
        11.0, 12.0, 13.0, 14.0, 21.0, 22.0, 23.0, 24.0, 31.0, 32.0, 33.0, 34.0,
    );

    // TODO: What's a more idiomatic/better way to convert a static matrix to a dynamic one?
    let d = DMatrix::from(a.get((0..a.nrows(), 0..a.ncols())).unwrap());

    // Note: these have to be macros, and not functions, because the input type is different
    // across the different tests. Moreover, the output type depends on the stride of the input,
    // which is different for static and dynamic matrices.
    macro_rules! dynamic_slice {
        ($mref:expr) => {
            DMatrixSlice::<_>::from($mref)
        };
    }
    macro_rules! dynamic_slice_mut {
        ($mref:expr) => {
            DMatrixSliceMut::<_>::from($mref)
        };
    }
    macro_rules! fixed_slice {
        ($mref:expr) => {
            MatrixSlice::<_, U3, U4, U1, U3>::from($mref)
        };
    }
    macro_rules! fixed_slice_mut {
        ($mref:expr) => {
            MatrixSliceMut::<_, U3, U4, U1, U3>::from($mref)
        };
    }

    // TODO: The `into_owned()` is a result of `PartialEq` not being implemented for different
    // Self and RHS. See issue #674. Once this is implemented, we can remove `into_owned`
    // from the below tests.

    // Construct slices from reference to a
    {
        assert_eq!(a, fixed_slice!(&a).into_owned());
        assert_eq!(d, dynamic_slice!(&a).into_owned());
    }

    // Construct slices from mutable reference to a
    {
        let mut a_clone = a.clone();
        assert_eq!(a, fixed_slice!(&mut a_clone).into_owned());
        assert_eq!(d, dynamic_slice!(&mut a_clone).into_owned());
    }

    // Construct mutable slices from mutable reference to a
    {
        let mut a_clone = a.clone();
        assert_eq!(a, fixed_slice_mut!(&mut a_clone).into_owned());
        assert_eq!(d, dynamic_slice_mut!(&mut a_clone).into_owned());
    }

    // Construct slices from reference to d
    {
        assert_eq!(a, fixed_slice!(&d).into_owned());
        assert_eq!(d, dynamic_slice!(&d).into_owned());
    }

    // Construct slices from mutable reference to d
    {
        let mut d_clone = a.clone();
        assert_eq!(a, fixed_slice!(&mut d_clone).into_owned());
        assert_eq!(d, dynamic_slice!(&mut d_clone).into_owned());
    }

    // Construct mutable slices from mutable reference to d
    {
        let mut d_clone = d.clone();
        assert_eq!(a, fixed_slice_mut!(&mut d_clone).into_owned());
        assert_eq!(d, dynamic_slice_mut!(&mut d_clone).into_owned());
    }

    // Construct slices from a slice of a
    {
        let mut a_slice = fixed_slice!(&a);
        assert_eq!(a, fixed_slice!(&a_slice).into_owned());
        assert_eq!(a, fixed_slice!(&mut a_slice).into_owned());
        assert_eq!(d, dynamic_slice!(&a_slice).into_owned());
        assert_eq!(d, dynamic_slice!(&mut a_slice).into_owned());
    }

    // Construct slices from a slice mut of a
    {
        // Need a clone of a here, so that we can both have a mutable borrow and compare equality
        let mut a_clone = a.clone();
        let mut a_slice = fixed_slice_mut!(&mut a_clone);

        assert_eq!(a, fixed_slice!(&a_slice).into_owned());
        assert_eq!(a, fixed_slice!(&mut a_slice).into_owned());
        assert_eq!(d, dynamic_slice!(&a_slice).into_owned());
        assert_eq!(d, dynamic_slice!(&mut a_slice).into_owned());
        assert_eq!(a, fixed_slice_mut!(&mut a_slice).into_owned());
        assert_eq!(d, dynamic_slice_mut!(&mut a_slice).into_owned());
    }
}