Function extendr_api::prelude::mat::from_raw_parts_mut

pub unsafe fn from_raw_parts_mut<'a, E>(
    ptr: <<E as Entity>::Group as ForType>::FaerOf<*mut <E as Entity>::Unit>,
    nrows: usize,
    ncols: usize,
    row_stride: isize,
    col_stride: isize,
) -> MatMut<'a, E>
where
    E: Entity,

Creates a MatMut from pointers to the matrix data, dimensions, and strides.

The row (resp. column) stride is the offset from the memory address of a given matrix element at indices (row: i, col: j), to the memory address of the matrix element at indices (row: i + 1, col: 0) (resp. (row: 0, col: i + 1)). This offset is specified in number of elements, not in bytes.

Safety

The behavior is undefined if any of the following conditions are violated:

• For each matrix unit, the entire memory region addressed by the matrix must be contained within a single allocation, accessible in its entirety by the corresponding pointer in ptr.
• For each matrix unit, the corresponding pointer must be non null and properly aligned, even for a zero-sized matrix.
• The values accessible by the matrix must be initialized at some point before they are read, or references to them are formed.
• No aliasing (including self aliasing) is allowed. In other words, none of the elements accessible by any matrix unit may be accessed for reads or writes by any other means for the duration of the lifetime 'a. No two elements within a single matrix unit may point to the same address (such a thing can be achieved with a zero stride, for example), and no two matrix units may point to the same address.

Example

use faer::mat;

// row major matrix with 2 rows, 3 columns, with a column at the end that we want to skip.
// the row stride is the pointer offset from the address of 1.0 to the address of 4.0,
// which is 4.
// the column stride is the pointer offset from the address of 1.0 to the address of 2.0,
// which is 1.
let mut data = [[1.0, 2.0, 3.0, f64::NAN], [4.0, 5.0, 6.0, f64::NAN]];
let mut matrix =
    unsafe { mat::from_raw_parts_mut::<f64>(data.as_mut_ptr() as *mut f64, 2, 3, 4, 1) };

let expected = mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
assert_eq!(expected.as_ref(), matrix);