Add macro for concatenating matrices

nalgebra-macros/tests/tests.rs

@@ -4,7 +4,7 @@ use nalgebra::{
     Point1, Point2, Point3, Point4, Point5, Point6, SMatrix, SVector, Vector1, Vector2, Vector3,
     Vector4, Vector5, Vector6,
 };
-use nalgebra_macros::{dmatrix, dvector, matrix, point, vector};
+use nalgebra_macros::{dmatrix, dvector, matrix, point, stack, vector};
 
 fn check_statically_same_type<T>(_: &T, _: &T) {}
 
@@ -305,3 +305,125 @@ fn dvector_arbitrary_expressions() {
     let a_expected = DVector::from_column_slice(&[1 + 2, 2 * 3, 4 * f(5 + 6), 7 - 8 * 9]);
     assert_eq_and_type!(a, a_expected);
 }
+
+#[test]
+fn stack_simple() {
+    let m = stack![
+        Matrix2::<usize>::identity(), 0;
+        0, &Matrix2::identity();
+    ];
+
+    assert_eq_and_type!(m, Matrix4::identity());
+}
+
+#[test]
+fn stack_diag() {
+    let m = stack![
+        0, matrix![1, 2; 3, 4;];
+        matrix![5, 6; 7, 8;], 0;
+    ];
+
+    let res = matrix![
+        0, 0, 1, 2;
+        0, 0, 3, 4;
+        5, 6, 0, 0;
+        7, 8, 0, 0;
+    ];
+
+    assert_eq_and_type!(m, res);
+}
+
+#[test]
+fn stack_dynamic() {
+    let m = stack![
+        matrix![ 1, 2; 3, 4; ], 0;
+        0, dmatrix![7, 8, 9; 10, 11, 12; ];
+    ];
+
+    let res = dmatrix![
+        1, 2, 0, 0, 0;
+        3, 4, 0, 0, 0;
+        0, 0, 7, 8, 9;
+        0, 0, 10, 11, 12;
+    ];
+
+    assert_eq_and_type!(m, res);
+}
+
+#[test]
+fn stack_nested() {
+    let m = stack![
+        stack![ matrix![1, 2; 3, 4;]; matrix![5, 6;]],
+        stack![ matrix![7;9;10;], matrix![11; 12; 13;] ];
+    ];
+
+    let res = matrix![
+        1, 2, 7, 11;
+        3, 4, 9, 12;
+        5, 6, 10, 13;
+    ];
+
+    assert_eq_and_type!(m, res);
+}
+
+#[test]
+fn stack_single() {
+    let a = matrix![1, 2; 3, 4];
+    let b = stack![a];
+
+    assert_eq_and_type!(a, b);
+}
+
+#[test]
+fn stack_single_row() {
+    let a = matrix![1, 2; 3, 4];
+    let m = stack![a, a];
+
+    let res = matrix![
+        1, 2, 1, 2;
+        3, 4, 3, 4;
+    ];
+
+    assert_eq_and_type!(m, res);
+}
+
+#[test]
+fn stack_single_col() {
+    let a = matrix![1, 2; 3, 4];
+    let m = stack![a; a];
+
+    let res = matrix![
+        1, 2;
+        3, 4;
+        1, 2;
+        3, 4;
+    ];
+
+    assert_eq_and_type!(m, res);
+}
+
+#[test]
+fn stack_expr() {
+    let a = matrix![1, 2; 3, 4];
+    let b = matrix![5, 6; 7, 8];
+    let m = stack![a + b; b - a];
+
+    let res = matrix![
+        6, 8;
+        10, 12;
+        4, 4;
+        4, 4;
+    ];
+
+    assert_eq_and_type!(m, res);
+}
+
+#[test]
+fn stack_trybuild_tests() {
+    let t = trybuild::TestCases::new();
+
+    // Verify error message when try to conactenate no matrices
+    t.compile_fail("tests/trybuild/stack_empty.rs");
+    t.compile_fail("tests/trybuild/stack_empty_row.rs");
+    t.compile_fail("tests/trybuild/stack_empty_col.rs");
+}

nalgebra-macros/tests/trybuild/stack_empty.rs

@@ -0,0 +1,5 @@
+use nalgebra_macros::stack;
+
+fn main() {
+    stack![];
+}

nalgebra-macros/tests/trybuild/stack_empty.stderr

@@ -0,0 +1,7 @@
+error: `stack` macro cannot be used without any arguments
+ --> tests/trybuild/stack_empty.rs:4:5
+  |
+4 |     stack![];
+  |     ^^^^^^^^
+  |
+  = note: this error originates in the macro `stack` (in Nightly builds, run with -Z macro-backtrace for more info)

nalgebra-macros/tests/trybuild/stack_empty_col.rs

@@ -0,0 +1,6 @@
+use nalgebra_macros::{matrix, stack};
+
+fn main() {
+    let m = matrix![1, 2; 3, 4];
+    stack![0, m];
+}

nalgebra-macros/tests/trybuild/stack_empty_col.stderr

@@ -0,0 +1,7 @@
+error: At least one element in each column must be an expression of type `Matrix`
+ --> tests/trybuild/stack_empty_col.rs:5:5
+  |
+5 |     stack![0, m];
+  |     ^^^^^^^^^^^^
+  |
+  = note: this error originates in the macro `stack` (in Nightly builds, run with -Z macro-backtrace for more info)

nalgebra-macros/tests/trybuild/stack_empty_row.rs

@@ -0,0 +1,6 @@
+use nalgebra_macros::{matrix, stack};
+
+fn main() {
+    let m = matrix![1, 2; 3, 4];
+    stack![0; m];
+}

nalgebra-macros/tests/trybuild/stack_empty_row.stderr

@@ -0,0 +1,7 @@
+error: At least one element in each row must be an expression of type `Matrix`
+ --> tests/trybuild/stack_empty_row.rs:5:5
+  |
+5 |     stack![0; m];
+  |     ^^^^^^^^^^^^
+  |
+  = note: this error originates in the macro `stack` (in Nightly builds, run with -Z macro-backtrace for more info)

src/base/constraint.rs

@@ -19,6 +19,16 @@ pub trait DimEq<D1: Dim, D2: Dim> {
     /// This is either equal to `D1` or `D2`, always choosing the one (if any) which is a type-level
     /// constant.
     type Representative: Dim;
+
+    /// This constructs a value of type `Representative` with the
+    /// correct value
+    fn representative(d1: D1, d2: D2) -> Option<Self::Representative> {
+        if d1.value() != d2.value() {
+            None
+        } else {
+            Some(Self::Representative::from_usize(d1.value()))
+        }
+    }
 }
 
 impl<D: Dim> DimEq<D, D> for ShapeConstraint {

src/lib.rs

@@ -155,7 +155,7 @@ pub use crate::sparse::*;
 pub use base as core;
 
 #[cfg(feature = "macros")]
-pub use nalgebra_macros::{dmatrix, dvector, matrix, point, vector};
+pub use nalgebra_macros::{dmatrix, dvector, matrix, point, stack, vector};
 
 use simba::scalar::SupersetOf;
 use std::cmp::{self, Ordering, PartialOrd};