How to reassign column vector of matrix?

[newtonharry]

Hi,

I'm trying to reassign a column within a mutable slice of a csc matrix and I'm not sure where I'm going wrong here:

pub fn merge_cols(
    matrix: &mut CsMat<f64>,
    left: usize,
    current: usize,
    deleted_indices: &mut HashSet<u64>,
) {
    let r = Range {
        start: left,
        end: (current + 1),
    };
    let mut acc: CsVec<f64> = CsVec::empty(matrix.rows().clone());
    let slice = matrix.slice_outer_mut(r);

    for (i, col_vec) in slice.outer_iterator().enumerate() {
        let index = i + left;
        if !deleted_indices.contains(&(index as u64)) {
            acc = acc + col_vec;
        }
        deleted_indices.insert(index as u64);
    }

    let col_view = matrix.outer_view_mut(current).unwrap();
    col_view.assign_elem(&acc);

    // * matrix.slice_outer_mut(current..current + 1) = acc
}

It's saying the slice can't be dereference but I'm not really sure where to go from here. Thanks!

[mulimoen]

I thimk you run into a problem since you are trying to modify the matrix inplace by adding more elements, which is incompatible with the sparse matrix format. If you only require an outer merge you can use append_outer_csvec, otherwise you might have to do some bookkeeping and assemble the matrix yourself

[newtonharry]

So perhaps I could get a slice up to and not including the left index and a slice from just after the right index and onwards. I could then perform something like this:

left_slice.append_outer_csvec(acc);
left_slice.append_outer_csvec(right_slice);

Is this what you're hinting at? I've used hstacking in scipy before but its quite an expensive operation as I might be doing it a few million times. I'm not sure how it compares to your hstack implementation.

[newtonharry]

This implementation compiles:

pub fn merge_cols(
    matrix: &mut CsMat<f64>,
    left: usize,
    current: usize,
    deleted_indices: &mut HashSet<u64>,
) {
    let r = Range {
        start: left,
        end: (current + 1),
    };
    let mut acc: CsVec<f64> = CsVec::empty(matrix.rows().clone());
    let slice = matrix.slice_outer_mut(r);

    for (i, col_vec) in slice.outer_iterator().enumerate() {
        let index = i + left;
        if !deleted_indices.contains(&(index as u64)) {
            acc = acc + col_vec;
        }
        deleted_indices.insert(index as u64);
    }

    let left_slice = matrix
        .slice_outer(0..left)
        .to_csc()
        .append_outer_csvec(acc.view());
    // let right_slice = matrix.slice_outer_mut(right + 1..matrix.cols() - 1);
    //
    // matrix.app
    // let col_view = matrix.outer_view_mut(current).unwrap();
    // col_view.assign_elem(acc);
    // hst
    // * matrix.slice_outer_mut(current..current + 1) = acc
}

[mulimoen]

That would work, but do note that slicing matrices like this is inefficient since you must copy lots of elements around. It could me more efficient to store the matrix as a vector of CsVec instead of cramming things into a CsMat

[newtonharry]

Great point! I'll try that out