No obvious way to concatenate vectors and matricies

[glfmn]

When using a dynamic matrix, there is no clear way to extend a matrix not with copies of a single element, but with a vector (like with insert_row or insert_column) or with a matrix (counterpart to insert_rows or insert_columns). In fact judging by the names, I thought that they used a vector and matrix respectively and not a single value.

This isn't mentioned at all in the reference and I haven't found anything in the API. Is there any reason that concatenation isn't supported when insert_row and insert_column exist? My current solution is to create a vec of vectors and use the from_columns constructor.

[sebcrozet]

This is not supported yet but could be added.
I agree the names can be misleading. Maybe we should rename them insert_row_from_element or something like this.

[glfmn]

Considering that there are already from_element methods I think that's good, only thing is it would be a breaking change, right?

I think it would also be nice to have methods to extend a matrix with a matrix or vector at the end rather than inserting them.

For the record my workaround was to create a Vec of the columns and use the from_columns function to make the matrix for my dataset:

    // Stride the range of included sets in this dataset
    for s in sets {
        // Load the images from the set which correspond to the training set
        for i in range.clone() {
            if let Ok(img) = image::open(format!("{}/s{}/{}.pgm", path, s, i)) {
                bounds = img.dimensions();
                images.push(image_vector(img));
            } else {
                return Err(format!("Failed to open image s{}/{}.pgm", s, i));
            }
        }
    }

[blankenshipz]

I think that specifically for the DVector type there should be methods to extend the DVector by concatenating another DVector (this is similar to append on Vec in the stdlib) and a method to add a single element (which would be similair to push on Vec)

@sebcrozet What do you think about this? Should this be a new issue?

[sebcrozet]

@blankenshipz Yes this would be useful! As you suggested this should be on a new issue.

[pwnorbitals]

I would like to bump this issue : there is now Extend for DVector, but I'm not aware of any utility that could help with concatenating SVectors

[Andlon]

So at one point I actually hacked together a prototype for a fairly generic solution to concatenating matrices and vectors. The tricky part is to make it work properly with static dimensions. I solved this by introducing a new trait Block and wrapper types VCat and HCat which can be used to construct conceptual "matrix blocks" (without actually constructing any intermediate matrices), so that at the end we can obtain the correct dimensions for the output and finally populate the individual blocks of the input. I never had the time to work further on this, but perhaps it can serve as a starting point for a solution.

https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=221a1aab484d6432d1203c92fcefcae4

The example above shows how you can do things like:

    let a = Matrix2::new(0, 0, 0, 0);
    let b = Matrix2::new(1, 1, 1, 1);
    let c = Matrix4::new(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2);
    
    let result: Matrix6x4<_> = bcat![a, b;
                                     c];
    println!("{}", result);

which outputs

  ┌         ┐
  │ 0 0 1 1 │
  │ 0 0 1 1 │
  │ 2 2 2 2 │
  │ 2 2 2 2 │
  │ 2 2 2 2 │
  │ 2 2 2 2 │
  └         ┘

I think it can be extended to support any number of desirable features.

(Note that the playground link might not work in the future if there are more breaking changes in nalgebra, since there is no way to pin dependency versions in the playground. But it should work with nalgebra version 0.27 I suppose, since I guess that's what's currently in the playground)

[Andlon]

Since another user asked for concatenation on Discord, I wanted to add some points about my previous suggestion. It is built around a Block trait like this:

trait Block<T> {
    type Rows: Dim;
    type Cols: Dim;
    
    fn shape(&self) -> (Self::Rows, Self::Cols);
    
    fn populate<S>(&self, output: &mut Matrix<T, Self::Rows, Self::Cols, S>)
    where 
        T: Scalar,
        S: StorageMut<T, Self::Rows, Self::Cols>;
}

Matrix types have a trivial Block impl. It is otherwise implemented by types corresponding to horizontal, vertical and diagonal concatenation (HCat and VCat in the linked prototype, I didn't have diagonal then):

struct Horizontal<X>(pub X);
struct Vertical<X>(pub X);
struct Diagonal<X>(pub X);

impl<T, B: Block<T>> Block<T> for Horizontal<(B,)>  { /* impl */ }
impl<T, B1: Block<T>, B2: Block<T>> Block<T> for Horizontal<(B1, B2)>  { /* impl */ }
// and so on for higher-arity tuples, plus a slice impl:
impl<'a, T, B: Block<T>> Block<T> for Horizontal<&'a [B]>  { /* impl */ }

// Analogous impls for `Vertical` and `Diagonal`

The macro bcat! then basically just wraps each "row" in the macro in Horizontal and wraps the whole thing in Vertical, so for example

bcat![a, b;
      c, d]

translates to allocating storage and populating the recursive block defined by

Vertical( (
  Horizontal((a, b)),
  Horizontal((c, d))
) )

These traits work across static and dynamic dimensions and mixes thereof by leveraging the support for dimension "algebra" already present innalgebra (see the linked prototype for details). Interestingly, the recursive nature of this API makes it much more powerful than just being able to handle "simple" concatenation like the above. Starting simple, we can do diagonal concatenation:

bcat![Diagonal((a, b))]

// equivalent in output to
bcat![        a, zero_1;
         zero_2,         b];
// with zero_1 and zero_2 appropriately sized matrices filled with zeros

But it doesn't stop there, we can mix and match these qualifiers almost arbitrarily. For example, say we want to construct the matrix

[ a, 0, b ]
[ 0, c, d ]
[ e, f, g ]

where 0 denotes a zero matrix of appropriate size. We could write this as:

bcat![
     Diagonal((a, c)), Vertical((b, d));
   Horizontal((e, f)),                g
]

The good news is that all of this happens with a single allocation: the output matrix is allocated once and each block is filled in recursively. Finally, we can also do all this with slices (so a dynamic number of matrices):

// Dynamic number of column entries
bcat![&[a, b];
      &[c, d]]

// Dynamic number of rows
bcat![Vertical(&[a, b, c])]

// Dynamic number of diagonal blocks
bcat![Diagonal(&[a, b, c])]

// Mix and match (matrices must be dimensionally compatible of course)
bcat![a, Diagonal(&[a, b, c]);
      d,              &[e, f]];

Undoubtedly there would be some details to work out, but at the surface, it seems this API would be remarkably powerful given its simplicity.

Unfortunately I don't foresee having time to look at this in the very near future, but I might be able to squeeze in a little bit of time soem time in the next few months? Alternatively I'd be happy to mentor someone who would like to give an implementation a try.

[sebcrozet]

This looks like a great idea @Andlon. Could we perhaps avoid having to write the Diagonal/Vertical/Horizontal by simply adding zeros? Instead of writing:

bcat![
     Diagonal((a, c)), Vertical((b, d));
   Horizontal((e, f)),                g
]

could the macro directly understand this:

bcat![
    a, 0, b;
    0, c, d;
    e, f, g;
]

where the macro would automatically understand that each 0 literal should be replaced by the properly sized 0 submatrix?