how to sub a vector row by row with nalgebra? about nalgebra HOT 5 CLOSED

Hi! You could do something like this:

    let mut mat = Matrix4x3::repeat(1);
    let vec = RowVector3::new(1, 2, 3);
    mat.row_iter_mut().for_each(|mut row| row -= vec);

from nalgebra.

@sebcrozet Thanks for your advice, but according to your advide, I was using RowVector to construct a vector, but it seems not right

let m = rs.row_mean();
let _v = m.as_slice().to_vec();
for row in rs.row_iter_mut(){
      row = row - RowVector::from_vec(_v);       
}

rs is a Matrix.

I cannot fix this ...

from nalgebra.

The error here originates from the fact that the compiler doesn’t know what kind of row vector you want (dynamically sized? staticaly sized?) So you can for example do DRowVector::from_vec(_v) instead, where DRowVector is a dynamically sized row vector.

Anyway, you don’t need that conversion at all. Your variable m is already a row vector (because row_mean returns a row vector). So the to_vec/from_vec are not needed.

In addition, you can’t do row = row - RowVector::from_vec(_v) because row is a matrix view (whereas the result of a binary operation must be a whole new vector, it can’t be a view on an existing vector). So you need to apply the subtraction in-place:

let mean = rs.row_mean();
for mut row in rs.row_iter_mut() {
    row -= &mean;
}

from nalgebra.

@sebcrozet Thanks for your help!

from nalgebra.

@sebcrozet Sorry but I didn't found the DRowVector type. Maybe we just left out pub type DRowVector<T>=Matrix<T, U1, Dyn, VecStorage<T, U1, Dyn>>; somewhere?

Regarding another question, though which I'm not sure if worth a new issue, I'm trying to subtracting a row from another row within the same matrix. Of course this can't be written as in other languages because of rust's borrow checker. So I have to copy the subtractee into a new DRowVector (which led me to this issue) like this:

pub type DRowVector<T>=Matrix<T, U1, Dyn, VecStorage<T, U1, Dyn>>;
let t: DRowVector<f64> = mat.row(i-1).into();
mat.row_mut(i).sub_assign(t);

which seems to be redundant. Is there already a zero-copy way to do this operation, or should we add something like split_at_mut?

from nalgebra.