Is there a good way to do an overlapping copy in ndarray in rust?

Question

Here's what I tried

use ndarray::{arr2, s};
let mut a = arr2(&[[1, 2, 3],
                   [4, 5, 6]]);
let b = arr2(&[[2, 3, 3],
               [5, 6, 6]]);

a.slice_mut(s![.., ..2]).assign(&a.slice_mut(s![.., 1..]));

which obviously fails because of the borrowing rules (playround link):

error[E0499]: cannot borrow `a` as mutable more than once at a time
  --> src/main.rs:13:38
   |
13 |     a.slice_mut(s![.., ..2]).assign(&a.slice_mut(s![.., 1..]));
   |     -                        ------  ^ second mutable borrow occurs here
   |     |                        |
   |     |                        first borrow later used by call
   |     first mutable borrow occurs here

Here a is what I have and b is what I'm trying to get.

In numpy it is as easy as a[:, :2] = a[:, 1:].

PS Maybe there's a simple solution in nalgebra crate?

Answer 1

In master branch of ndarray there's a special macro for that, more convenient than split_at_mut() in that it supports arbitrary slices - but it panics when the slices overlap:

use ndarray::multislice;
use ndarray::prelude::*;
let mut arr: Array1<_> = (0..4).collect();
let (mut a, mut b) = multislice!(arr, mut [..;2], mut [1..;2]);
a.assign(&b);

gives [1,1,3,3]

They even solve a Diophantine equation to check it. It happens at runtime as opposed to compile-time split_at_mut.

Answer 2

Ok, got it

use ndarray::{arr2, s,Array};

let mut a = arr2(&[[1, 2, 3],
                   [4, 5, 6]]);
unsafe{
    let b = a.as_mut_ptr();
    let c = Vec::<i32>::from_raw_parts(b, 6, 6);
    let mut d = Array::from_shape_vec((2, 3), c).unwrap();
    a.slice_mut(s![.., ..2]).assign(&d.slice_mut(s![.., 1..]));
    std::mem::forget(d);
}
println!("{:?}",a);