2016-12-05 05:44:42 +08:00
|
|
|
use std::marker::PhantomData;
|
2021-06-17 15:42:47 +08:00
|
|
|
use std::ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo};
|
2017-08-03 01:37:44 +08:00
|
|
|
use std::slice;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
use crate::base::allocator::Allocator;
|
2019-03-23 21:29:07 +08:00
|
|
|
use crate::base::default_allocator::DefaultAllocator;
|
2021-01-03 22:20:34 +08:00
|
|
|
use crate::base::dimension::{Const, Dim, DimName, Dynamic, IsNotStaticOne, U1};
|
2019-03-23 21:29:07 +08:00
|
|
|
use crate::base::iter::MatrixIter;
|
2021-08-03 00:41:46 +08:00
|
|
|
use crate::base::storage::{IsContiguous, Owned, RawStorage, RawStorageMut, Storage};
|
|
|
|
use crate::base::{Matrix, Scalar};
|
2022-11-14 23:41:01 +08:00
|
|
|
use crate::constraint::{DimEq, ShapeConstraint};
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2022-11-11 22:46:04 +08:00
|
|
|
macro_rules! view_storage_impl (
|
|
|
|
($doc: expr; $Storage: ident as $SRef: ty; $legacy_name:ident => $T: ident.$get_addr: ident ($Ptr: ty as $Ref: ty)) => {
|
2017-02-13 01:17:09 +08:00
|
|
|
#[doc = $doc]
|
2017-08-03 01:37:44 +08:00
|
|
|
#[derive(Debug)]
|
2022-11-11 22:46:04 +08:00
|
|
|
pub struct $T<'a, T, R: Dim, C: Dim, RStride: Dim, CStride: Dim> {
|
2016-12-05 05:44:42 +08:00
|
|
|
ptr: $Ptr,
|
|
|
|
shape: (R, C),
|
|
|
|
strides: (RStride, CStride),
|
2017-08-03 01:37:44 +08:00
|
|
|
_phantoms: PhantomData<$Ref>,
|
2016-12-05 05:44:42 +08:00
|
|
|
}
|
|
|
|
|
2022-11-11 22:46:04 +08:00
|
|
|
#[doc = $doc]
|
|
|
|
///
|
|
|
|
/// This type alias exists only for legacy purposes and is deprecated. It will be removed
|
|
|
|
/// in a future release. Please use
|
|
|
|
/// [`
|
|
|
|
#[doc = stringify!($T)]
|
|
|
|
/// `] instead. See [issue #1076](https://github.com/dimforge/nalgebra/issues/1076)
|
|
|
|
/// for the rationale.
|
|
|
|
#[deprecated = "Use ViewStorage(Mut) instead."]
|
|
|
|
pub type $legacy_name<'a, T, R, C, RStride, CStride> = $T<'a, T, R, C, RStride, CStride>;
|
|
|
|
|
2021-07-14 17:25:16 +08:00
|
|
|
unsafe impl<'a, T: Send, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Send
|
2021-04-11 17:00:38 +08:00
|
|
|
for $T<'a, T, R, C, RStride, CStride>
|
2018-08-13 12:48:55 +08:00
|
|
|
{}
|
|
|
|
|
2021-07-14 17:25:16 +08:00
|
|
|
unsafe impl<'a, T: Sync, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Sync
|
2021-04-11 17:00:38 +08:00
|
|
|
for $T<'a, T, R, C, RStride, CStride>
|
2018-08-13 12:48:55 +08:00
|
|
|
{}
|
|
|
|
|
2021-07-14 17:25:16 +08:00
|
|
|
impl<'a, T, R: Dim, C: Dim, RStride: Dim, CStride: Dim> $T<'a, T, R, C, RStride, CStride> {
|
2022-11-11 22:46:04 +08:00
|
|
|
/// Create a new matrix view without bounds checking and from a raw pointer.
|
2018-02-02 19:26:00 +08:00
|
|
|
#[inline]
|
|
|
|
pub unsafe fn from_raw_parts(ptr: $Ptr,
|
|
|
|
shape: (R, C),
|
|
|
|
strides: (RStride, CStride))
|
|
|
|
-> Self
|
|
|
|
where RStride: Dim,
|
|
|
|
CStride: Dim {
|
|
|
|
|
|
|
|
$T {
|
2020-10-26 20:25:55 +08:00
|
|
|
ptr,
|
|
|
|
shape,
|
|
|
|
strides,
|
2018-02-02 19:26:00 +08:00
|
|
|
_phantoms: PhantomData
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
// Dynamic is arbitrary. It's just to be able to call the constructors with `Slice::`
|
2021-07-14 17:25:16 +08:00
|
|
|
impl<'a, T, R: Dim, C: Dim> $T<'a, T, R, C, Dynamic, Dynamic> {
|
2022-11-11 22:46:04 +08:00
|
|
|
/// Create a new matrix view without bounds checking.
|
2016-12-05 05:44:42 +08:00
|
|
|
#[inline]
|
|
|
|
pub unsafe fn new_unchecked<RStor, CStor, S>(storage: $SRef, start: (usize, usize), shape: (R, C))
|
2021-04-11 17:00:38 +08:00
|
|
|
-> $T<'a, T, R, C, S::RStride, S::CStride>
|
2016-12-05 05:44:42 +08:00
|
|
|
where RStor: Dim,
|
|
|
|
CStor: Dim,
|
2021-04-11 17:00:38 +08:00
|
|
|
S: $Storage<T, RStor, CStor> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
|
|
let strides = storage.strides();
|
|
|
|
$T::new_with_strides_unchecked(storage, start, shape, strides)
|
|
|
|
}
|
|
|
|
|
2022-11-11 22:46:04 +08:00
|
|
|
/// Create a new matrix view without bounds checking.
|
2016-12-05 05:44:42 +08:00
|
|
|
#[inline]
|
|
|
|
pub unsafe fn new_with_strides_unchecked<S, RStor, CStor, RStride, CStride>(storage: $SRef,
|
|
|
|
start: (usize, usize),
|
|
|
|
shape: (R, C),
|
|
|
|
strides: (RStride, CStride))
|
2021-04-11 17:00:38 +08:00
|
|
|
-> $T<'a, T, R, C, RStride, CStride>
|
2016-12-05 05:44:42 +08:00
|
|
|
where RStor: Dim,
|
|
|
|
CStor: Dim,
|
2021-04-11 17:00:38 +08:00
|
|
|
S: $Storage<T, RStor, CStor>,
|
2016-12-05 05:44:42 +08:00
|
|
|
RStride: Dim,
|
|
|
|
CStride: Dim {
|
2017-08-03 01:37:44 +08:00
|
|
|
$T::from_raw_parts(storage.$get_addr(start.0, start.1), shape, strides)
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
}
|
2021-06-18 08:23:40 +08:00
|
|
|
|
2021-07-14 17:25:16 +08:00
|
|
|
impl <'a, T, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
|
2021-06-18 08:23:40 +08:00
|
|
|
$T<'a, T, R, C, RStride, CStride>
|
2021-06-18 19:18:33 +08:00
|
|
|
where
|
2021-08-03 00:41:46 +08:00
|
|
|
Self: RawStorage<T, R, C> + IsContiguous
|
2021-06-18 08:23:40 +08:00
|
|
|
{
|
2022-11-11 22:46:04 +08:00
|
|
|
/// Extracts the original slice from this storage.
|
2021-06-18 08:23:40 +08:00
|
|
|
pub fn into_slice(self) -> &'a [T] {
|
|
|
|
let (nrows, ncols) = self.shape();
|
|
|
|
if nrows.value() != 0 && ncols.value() != 0 {
|
|
|
|
let sz = self.linear_index(nrows.value() - 1, ncols.value() - 1);
|
|
|
|
unsafe { slice::from_raw_parts(self.ptr, sz + 1) }
|
|
|
|
} else {
|
|
|
|
unsafe { slice::from_raw_parts(self.ptr, 0) }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2022-11-11 22:46:04 +08:00
|
|
|
view_storage_impl!("A matrix data storage for a matrix view. Only contains an internal reference \
|
2017-02-13 01:17:09 +08:00
|
|
|
to another matrix data storage.";
|
2022-11-11 22:46:04 +08:00
|
|
|
RawStorage as &'a S; SliceStorage => ViewStorage.get_address_unchecked(*const T as &'a T));
|
2017-02-13 01:17:09 +08:00
|
|
|
|
2022-11-11 22:46:04 +08:00
|
|
|
view_storage_impl!("A mutable matrix data storage for mutable matrix view. Only contains an \
|
2017-02-13 01:17:09 +08:00
|
|
|
internal mutable reference to another matrix data storage.";
|
2022-11-11 22:46:04 +08:00
|
|
|
RawStorageMut as &'a mut S; SliceStorageMut => ViewStorageMut.get_address_unchecked_mut(*mut T as &'a mut T)
|
2017-02-13 01:17:09 +08:00
|
|
|
);
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Copy
|
2022-11-11 22:46:04 +08:00
|
|
|
for ViewStorage<'a, T, R, C, RStride, CStride>
|
2018-11-07 01:32:20 +08:00
|
|
|
{
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Clone
|
2022-11-11 22:46:04 +08:00
|
|
|
for ViewStorage<'a, T, R, C, RStride, CStride>
|
2018-08-13 12:48:55 +08:00
|
|
|
{
|
2016-12-05 05:44:42 +08:00
|
|
|
#[inline]
|
|
|
|
fn clone(&self) -> Self {
|
2019-02-17 05:29:41 +08:00
|
|
|
Self {
|
2018-02-02 19:26:35 +08:00
|
|
|
ptr: self.ptr,
|
|
|
|
shape: self.shape,
|
|
|
|
strides: self.strides,
|
2016-12-05 05:44:42 +08:00
|
|
|
_phantoms: PhantomData,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
|
2022-11-11 22:46:04 +08:00
|
|
|
ViewStorageMut<'a, T, R, C, RStride, CStride>
|
2021-06-18 19:18:33 +08:00
|
|
|
where
|
2021-08-03 00:41:46 +08:00
|
|
|
Self: RawStorageMut<T, R, C> + IsContiguous,
|
2021-06-18 08:23:40 +08:00
|
|
|
{
|
|
|
|
/// Extracts the original slice from this storage
|
|
|
|
pub fn into_slice_mut(self) -> &'a mut [T] {
|
|
|
|
let (nrows, ncols) = self.shape();
|
|
|
|
if nrows.value() != 0 && ncols.value() != 0 {
|
|
|
|
let sz = self.linear_index(nrows.value() - 1, ncols.value() - 1);
|
|
|
|
unsafe { slice::from_raw_parts_mut(self.ptr, sz + 1) }
|
|
|
|
} else {
|
|
|
|
unsafe { slice::from_raw_parts_mut(self.ptr, 0) }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-05 05:44:42 +08:00
|
|
|
macro_rules! storage_impl(
|
|
|
|
($($T: ident),* $(,)*) => {$(
|
2021-08-03 00:41:46 +08:00
|
|
|
unsafe impl<'a, T, R: Dim, C: Dim, RStride: Dim, CStride: Dim> RawStorage<T, R, C>
|
2021-04-11 17:00:38 +08:00
|
|
|
for $T<'a, T, R, C, RStride, CStride> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
|
|
type RStride = RStride;
|
|
|
|
type CStride = CStride;
|
|
|
|
|
|
|
|
#[inline]
|
2021-04-11 17:00:38 +08:00
|
|
|
fn ptr(&self) -> *const T {
|
2016-12-05 05:44:42 +08:00
|
|
|
self.ptr
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn shape(&self) -> (R, C) {
|
|
|
|
self.shape
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn strides(&self) -> (Self::RStride, Self::CStride) {
|
|
|
|
self.strides
|
|
|
|
}
|
2017-08-03 01:37:44 +08:00
|
|
|
|
|
|
|
#[inline]
|
2021-07-09 00:15:08 +08:00
|
|
|
fn is_contiguous(&self) -> bool {
|
2017-08-03 01:37:44 +08:00
|
|
|
// Common cases that can be deduced at compile-time even if one of the dimensions
|
|
|
|
// is Dynamic.
|
|
|
|
if (RStride::is::<U1>() && C::is::<U1>()) || // Column vector.
|
|
|
|
(CStride::is::<U1>() && R::is::<U1>()) { // Row vector.
|
|
|
|
true
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
let (nrows, _) = self.shape();
|
|
|
|
let (srows, scols) = self.strides();
|
|
|
|
|
|
|
|
srows.value() == 1 && scols.value() == nrows.value()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
2021-06-17 15:46:49 +08:00
|
|
|
unsafe fn as_slice_unchecked(&self) -> &[T] {
|
2017-08-03 01:37:44 +08:00
|
|
|
let (nrows, ncols) = self.shape();
|
|
|
|
if nrows.value() != 0 && ncols.value() != 0 {
|
|
|
|
let sz = self.linear_index(nrows.value() - 1, ncols.value() - 1);
|
2021-06-17 15:46:49 +08:00
|
|
|
slice::from_raw_parts(self.ptr, sz + 1)
|
2017-08-03 01:37:44 +08:00
|
|
|
}
|
|
|
|
else {
|
2021-06-17 15:46:49 +08:00
|
|
|
slice::from_raw_parts(self.ptr, 0)
|
2017-08-03 01:37:44 +08:00
|
|
|
}
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
}
|
2021-08-03 00:41:46 +08:00
|
|
|
|
|
|
|
unsafe impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Storage<T, R, C>
|
|
|
|
for $T<'a, T, R, C, RStride, CStride> {
|
|
|
|
#[inline]
|
|
|
|
fn into_owned(self) -> Owned<T, R, C>
|
|
|
|
where DefaultAllocator: Allocator<T, R, C> {
|
|
|
|
self.clone_owned()
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn clone_owned(&self) -> Owned<T, R, C>
|
|
|
|
where DefaultAllocator: Allocator<T, R, C> {
|
|
|
|
let (nrows, ncols) = self.shape();
|
|
|
|
let it = MatrixIter::new(self).cloned();
|
|
|
|
DefaultAllocator::allocate_from_iterator(nrows, ncols, it)
|
|
|
|
}
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
)*}
|
|
|
|
);
|
|
|
|
|
2022-11-11 22:46:04 +08:00
|
|
|
storage_impl!(ViewStorage, ViewStorageMut);
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
unsafe impl<'a, T, R: Dim, C: Dim, RStride: Dim, CStride: Dim> RawStorageMut<T, R, C>
|
2022-11-11 22:46:04 +08:00
|
|
|
for ViewStorageMut<'a, T, R, C, RStride, CStride>
|
2018-08-13 12:48:55 +08:00
|
|
|
{
|
2016-12-05 05:44:42 +08:00
|
|
|
#[inline]
|
2021-04-11 17:00:38 +08:00
|
|
|
fn ptr_mut(&mut self) -> *mut T {
|
2016-12-05 05:44:42 +08:00
|
|
|
self.ptr
|
|
|
|
}
|
2017-08-03 01:37:44 +08:00
|
|
|
|
|
|
|
#[inline]
|
2021-06-17 15:46:49 +08:00
|
|
|
unsafe fn as_mut_slice_unchecked(&mut self) -> &mut [T] {
|
2017-08-03 01:37:44 +08:00
|
|
|
let (nrows, ncols) = self.shape();
|
|
|
|
if nrows.value() != 0 && ncols.value() != 0 {
|
|
|
|
let sz = self.linear_index(nrows.value() - 1, ncols.value() - 1);
|
2021-06-17 15:46:49 +08:00
|
|
|
slice::from_raw_parts_mut(self.ptr, sz + 1)
|
2018-02-02 19:26:35 +08:00
|
|
|
} else {
|
2021-06-17 15:46:49 +08:00
|
|
|
slice::from_raw_parts_mut(self.ptr, 0)
|
2017-08-03 01:37:44 +08:00
|
|
|
}
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
}
|
|
|
|
|
2022-11-11 22:46:04 +08:00
|
|
|
unsafe impl<'a, T, R: Dim, CStride: Dim> IsContiguous for ViewStorage<'a, T, R, U1, U1, CStride> {}
|
2021-08-03 00:41:46 +08:00
|
|
|
unsafe impl<'a, T, R: Dim, CStride: Dim> IsContiguous
|
2022-11-11 22:46:04 +08:00
|
|
|
for ViewStorageMut<'a, T, R, U1, U1, CStride>
|
2020-04-06 00:49:48 +08:00
|
|
|
{
|
|
|
|
}
|
2019-01-28 18:22:57 +08:00
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
unsafe impl<'a, T, R: DimName, C: Dim + IsNotStaticOne> IsContiguous
|
2022-11-11 22:46:04 +08:00
|
|
|
for ViewStorage<'a, T, R, C, U1, R>
|
2020-04-06 00:49:48 +08:00
|
|
|
{
|
|
|
|
}
|
2021-08-03 00:41:46 +08:00
|
|
|
unsafe impl<'a, T, R: DimName, C: Dim + IsNotStaticOne> IsContiguous
|
2022-11-11 22:46:04 +08:00
|
|
|
for ViewStorageMut<'a, T, R, C, U1, R>
|
2020-04-06 00:49:48 +08:00
|
|
|
{
|
|
|
|
}
|
2019-01-28 18:22:57 +08:00
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
2016-12-05 05:44:42 +08:00
|
|
|
#[inline]
|
2022-11-14 21:42:23 +08:00
|
|
|
fn assert_view_index(
|
2018-02-02 19:26:35 +08:00
|
|
|
&self,
|
|
|
|
start: (usize, usize),
|
|
|
|
shape: (usize, usize),
|
|
|
|
steps: (usize, usize),
|
2020-04-06 00:49:48 +08:00
|
|
|
) {
|
2016-12-05 05:44:42 +08:00
|
|
|
let my_shape = self.shape();
|
2017-08-14 01:52:57 +08:00
|
|
|
// NOTE: we don't do any subtraction to avoid underflow for zero-sized matrices.
|
|
|
|
//
|
|
|
|
// Terms that would have been negative are moved to the other side of the inequality
|
|
|
|
// instead.
|
2018-02-02 19:26:35 +08:00
|
|
|
assert!(
|
|
|
|
start.0 + (steps.0 + 1) * shape.0 <= my_shape.0 + steps.0,
|
|
|
|
"Matrix slicing out of bounds."
|
|
|
|
);
|
|
|
|
assert!(
|
|
|
|
start.1 + (steps.1 + 1) * shape.1 <= my_shape.1 + steps.1,
|
|
|
|
"Matrix slicing out of bounds."
|
|
|
|
);
|
2016-12-05 05:44:42 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
macro_rules! matrix_view_impl (
|
2022-11-11 23:10:39 +08:00
|
|
|
($me: ident: $Me: ty, $MatrixView: ident, $ViewStorage: ident, $Storage: ident.$get_addr: ident (), $data: expr;
|
2016-12-05 05:44:42 +08:00
|
|
|
$row: ident,
|
2017-08-03 01:37:44 +08:00
|
|
|
$row_part: ident,
|
2016-12-05 05:44:42 +08:00
|
|
|
$rows: ident,
|
|
|
|
$rows_with_step: ident,
|
|
|
|
$fixed_rows: ident,
|
|
|
|
$fixed_rows_with_step: ident,
|
|
|
|
$rows_generic: ident,
|
2017-08-03 01:37:44 +08:00
|
|
|
$rows_generic_with_step: ident,
|
2016-12-05 05:44:42 +08:00
|
|
|
$column: ident,
|
2017-08-03 01:37:44 +08:00
|
|
|
$column_part: ident,
|
2016-12-05 05:44:42 +08:00
|
|
|
$columns: ident,
|
|
|
|
$columns_with_step: ident,
|
|
|
|
$fixed_columns: ident,
|
|
|
|
$fixed_columns_with_step: ident,
|
|
|
|
$columns_generic: ident,
|
2017-08-03 01:37:44 +08:00
|
|
|
$columns_generic_with_step: ident,
|
2022-11-14 21:02:36 +08:00
|
|
|
$slice: ident => $view:ident,
|
|
|
|
$slice_with_steps: ident => $view_with_steps:ident,
|
|
|
|
$fixed_slice: ident => $fixed_view:ident,
|
|
|
|
$fixed_slice_with_steps: ident => $fixed_view_with_steps:ident,
|
|
|
|
$generic_slice: ident => $generic_view:ident,
|
|
|
|
$generic_slice_with_steps: ident => $generic_view_with_steps:ident,
|
2017-08-03 01:37:44 +08:00
|
|
|
$rows_range_pair: ident,
|
|
|
|
$columns_range_pair: ident) => {
|
2020-11-14 01:34:33 +08:00
|
|
|
/*
|
|
|
|
*
|
|
|
|
* Row slicing.
|
|
|
|
*
|
|
|
|
*/
|
2022-11-14 21:02:36 +08:00
|
|
|
/// Returns a view containing the i-th row of this matrix.
|
2020-11-14 01:34:33 +08:00
|
|
|
#[inline]
|
2022-11-11 23:10:39 +08:00
|
|
|
pub fn $row($me: $Me, i: usize) -> $MatrixView<'_, T, U1, C, S::RStride, S::CStride> {
|
2021-04-11 17:00:38 +08:00
|
|
|
$me.$fixed_rows::<1>(i)
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
/// Returns a view containing the `n` first elements of the i-th row of this matrix.
|
2020-11-14 01:34:33 +08:00
|
|
|
#[inline]
|
2022-11-11 23:10:39 +08:00
|
|
|
pub fn $row_part($me: $Me, i: usize, n: usize) -> $MatrixView<'_, T, U1, Dynamic, S::RStride, S::CStride> {
|
2022-11-14 21:14:42 +08:00
|
|
|
$me.$generic_view((i, 0), (Const::<1>, Dynamic::new(n)))
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Extracts from this matrix a set of consecutive rows.
|
|
|
|
#[inline]
|
|
|
|
pub fn $rows($me: $Me, first_row: usize, nrows: usize)
|
2022-11-11 23:10:39 +08:00
|
|
|
-> $MatrixView<'_, T, Dynamic, C, S::RStride, S::CStride> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
$me.$rows_generic(first_row, Dynamic::new(nrows))
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Extracts from this matrix a set of consecutive rows regularly skipping `step` rows.
|
|
|
|
#[inline]
|
|
|
|
pub fn $rows_with_step($me: $Me, first_row: usize, nrows: usize, step: usize)
|
2022-11-11 23:10:39 +08:00
|
|
|
-> $MatrixView<'_, T, Dynamic, C, Dynamic, S::CStride> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
$me.$rows_generic_with_step(first_row, Dynamic::new(nrows), step)
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Extracts a compile-time number of consecutive rows from this matrix.
|
|
|
|
#[inline]
|
2022-11-14 21:02:36 +08:00
|
|
|
pub fn $fixed_rows<const RVIEW: usize>($me: $Me, first_row: usize)
|
|
|
|
-> $MatrixView<'_, T, Const<RVIEW>, C, S::RStride, S::CStride> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
$me.$rows_generic(first_row, Const::<RVIEW>)
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Extracts from this matrix a compile-time number of rows regularly skipping `step`
|
|
|
|
/// rows.
|
|
|
|
#[inline]
|
2022-11-14 21:02:36 +08:00
|
|
|
pub fn $fixed_rows_with_step<const RVIEW: usize>($me: $Me, first_row: usize, step: usize)
|
|
|
|
-> $MatrixView<'_, T, Const<RVIEW>, C, Dynamic, S::CStride> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
$me.$rows_generic_with_step(first_row, Const::<RVIEW>, step)
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Extracts from this matrix `nrows` rows regularly skipping `step` rows. Both
|
|
|
|
/// argument may or may not be values known at compile-time.
|
|
|
|
#[inline]
|
2022-11-14 21:02:36 +08:00
|
|
|
pub fn $rows_generic<RView: Dim>($me: $Me, row_start: usize, nrows: RView)
|
|
|
|
-> $MatrixView<'_, T, RView, C, S::RStride, S::CStride> {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
let my_shape = $me.shape_generic();
|
2022-11-14 21:42:23 +08:00
|
|
|
$me.assert_view_index((row_start, 0), (nrows.value(), my_shape.1.value()), (0, 0));
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
let shape = (nrows, my_shape.1);
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
unsafe {
|
2022-11-11 22:46:04 +08:00
|
|
|
let data = $ViewStorage::new_unchecked($data, (row_start, 0), shape);
|
2021-08-03 00:41:46 +08:00
|
|
|
Matrix::from_data_statically_unchecked(data)
|
2017-08-03 01:37:44 +08:00
|
|
|
}
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Extracts from this matrix `nrows` rows regularly skipping `step` rows. Both
|
|
|
|
/// argument may or may not be values known at compile-time.
|
|
|
|
#[inline]
|
2022-11-14 21:02:36 +08:00
|
|
|
pub fn $rows_generic_with_step<RView>($me: $Me, row_start: usize, nrows: RView, step: usize)
|
|
|
|
-> $MatrixView<'_, T, RView, C, Dynamic, S::CStride>
|
|
|
|
where RView: Dim {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
let my_shape = $me.shape_generic();
|
2020-11-14 01:34:33 +08:00
|
|
|
let my_strides = $me.data.strides();
|
2022-11-14 21:42:23 +08:00
|
|
|
$me.assert_view_index((row_start, 0), (nrows.value(), my_shape.1.value()), (step, 0));
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
let strides = (Dynamic::new((step + 1) * my_strides.0.value()), my_strides.1);
|
2021-08-03 00:41:46 +08:00
|
|
|
let shape = (nrows, my_shape.1);
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
unsafe {
|
2022-11-11 22:46:04 +08:00
|
|
|
let data = $ViewStorage::new_with_strides_unchecked($data, (row_start, 0), shape, strides);
|
2021-08-03 00:41:46 +08:00
|
|
|
Matrix::from_data_statically_unchecked(data)
|
2016-12-05 05:44:42 +08:00
|
|
|
}
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/*
|
|
|
|
*
|
|
|
|
* Column slicing.
|
|
|
|
*
|
|
|
|
*/
|
2022-11-14 21:02:36 +08:00
|
|
|
/// Returns a view containing the i-th column of this matrix.
|
2020-11-14 01:34:33 +08:00
|
|
|
#[inline]
|
2022-11-11 23:10:39 +08:00
|
|
|
pub fn $column($me: $Me, i: usize) -> $MatrixView<'_, T, R, U1, S::RStride, S::CStride> {
|
2021-04-11 17:00:38 +08:00
|
|
|
$me.$fixed_columns::<1>(i)
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
/// Returns a view containing the `n` first elements of the i-th column of this matrix.
|
2020-11-14 01:34:33 +08:00
|
|
|
#[inline]
|
2022-11-11 23:10:39 +08:00
|
|
|
pub fn $column_part($me: $Me, i: usize, n: usize) -> $MatrixView<'_, T, Dynamic, U1, S::RStride, S::CStride> {
|
2022-11-14 21:02:36 +08:00
|
|
|
$me.$generic_view((0, i), (Dynamic::new(n), Const::<1>))
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Extracts from this matrix a set of consecutive columns.
|
|
|
|
#[inline]
|
|
|
|
pub fn $columns($me: $Me, first_col: usize, ncols: usize)
|
2022-11-11 23:10:39 +08:00
|
|
|
-> $MatrixView<'_, T, R, Dynamic, S::RStride, S::CStride> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
$me.$columns_generic(first_col, Dynamic::new(ncols))
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Extracts from this matrix a set of consecutive columns regularly skipping `step`
|
|
|
|
/// columns.
|
|
|
|
#[inline]
|
|
|
|
pub fn $columns_with_step($me: $Me, first_col: usize, ncols: usize, step: usize)
|
2022-11-11 23:10:39 +08:00
|
|
|
-> $MatrixView<'_, T, R, Dynamic, S::RStride, Dynamic> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
$me.$columns_generic_with_step(first_col, Dynamic::new(ncols), step)
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Extracts a compile-time number of consecutive columns from this matrix.
|
|
|
|
#[inline]
|
2022-11-14 21:02:36 +08:00
|
|
|
pub fn $fixed_columns<const CVIEW: usize>($me: $Me, first_col: usize)
|
|
|
|
-> $MatrixView<'_, T, R, Const<CVIEW>, S::RStride, S::CStride> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
$me.$columns_generic(first_col, Const::<CVIEW>)
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Extracts from this matrix a compile-time number of columns regularly skipping
|
|
|
|
/// `step` columns.
|
|
|
|
#[inline]
|
2022-11-14 21:02:36 +08:00
|
|
|
pub fn $fixed_columns_with_step<const CVIEW: usize>($me: $Me, first_col: usize, step: usize)
|
|
|
|
-> $MatrixView<'_, T, R, Const<CVIEW>, S::RStride, Dynamic> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
$me.$columns_generic_with_step(first_col, Const::<CVIEW>, step)
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Extracts from this matrix `ncols` columns. The number of columns may or may not be
|
|
|
|
/// known at compile-time.
|
|
|
|
#[inline]
|
2022-11-14 21:02:36 +08:00
|
|
|
pub fn $columns_generic<CView: Dim>($me: $Me, first_col: usize, ncols: CView)
|
|
|
|
-> $MatrixView<'_, T, R, CView, S::RStride, S::CStride> {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
let my_shape = $me.shape_generic();
|
2022-11-14 21:42:23 +08:00
|
|
|
$me.assert_view_index((0, first_col), (my_shape.0.value(), ncols.value()), (0, 0));
|
2020-11-14 01:34:33 +08:00
|
|
|
let shape = (my_shape.0, ncols);
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
unsafe {
|
2022-11-11 22:46:04 +08:00
|
|
|
let data = $ViewStorage::new_unchecked($data, (0, first_col), shape);
|
2021-08-03 00:41:46 +08:00
|
|
|
Matrix::from_data_statically_unchecked(data)
|
2016-12-05 05:44:42 +08:00
|
|
|
}
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Extracts from this matrix `ncols` columns skipping `step` columns. Both argument may
|
|
|
|
/// or may not be values known at compile-time.
|
|
|
|
#[inline]
|
2022-11-14 21:02:36 +08:00
|
|
|
pub fn $columns_generic_with_step<CView: Dim>($me: $Me, first_col: usize, ncols: CView, step: usize)
|
|
|
|
-> $MatrixView<'_, T, R, CView, S::RStride, Dynamic> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
let my_shape = $me.shape_generic();
|
2020-11-14 01:34:33 +08:00
|
|
|
let my_strides = $me.data.strides();
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2022-11-14 21:42:23 +08:00
|
|
|
$me.assert_view_index((0, first_col), (my_shape.0.value(), ncols.value()), (0, step));
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
let strides = (my_strides.0, Dynamic::new((step + 1) * my_strides.1.value()));
|
2021-08-03 00:41:46 +08:00
|
|
|
let shape = (my_shape.0, ncols);
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
unsafe {
|
2022-11-11 22:46:04 +08:00
|
|
|
let data = $ViewStorage::new_with_strides_unchecked($data, (0, first_col), shape, strides);
|
2021-08-03 00:41:46 +08:00
|
|
|
Matrix::from_data_statically_unchecked(data)
|
2016-12-05 05:44:42 +08:00
|
|
|
}
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/*
|
|
|
|
*
|
|
|
|
* General slicing.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
/// Slices this matrix starting at its component `(irow, icol)` and with `(nrows, ncols)`
|
|
|
|
/// consecutive elements.
|
|
|
|
#[inline]
|
2022-11-14 21:02:36 +08:00
|
|
|
#[deprecated = slice_deprecation_note!($view)]
|
2020-11-14 01:34:33 +08:00
|
|
|
pub fn $slice($me: $Me, start: (usize, usize), shape: (usize, usize))
|
2022-11-11 23:10:39 +08:00
|
|
|
-> $MatrixView<'_, T, Dynamic, Dynamic, S::RStride, S::CStride> {
|
2022-11-14 21:02:36 +08:00
|
|
|
$me.$view(start, shape)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return a view of this matrix starting at its component `(irow, icol)` and with `(nrows, ncols)`
|
|
|
|
/// consecutive elements.
|
|
|
|
#[inline]
|
|
|
|
pub fn $view($me: $Me, start: (usize, usize), shape: (usize, usize))
|
|
|
|
-> $MatrixView<'_, T, Dynamic, Dynamic, S::RStride, S::CStride> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2022-11-14 21:42:23 +08:00
|
|
|
$me.assert_view_index(start, shape, (0, 0));
|
2020-11-14 01:34:33 +08:00
|
|
|
let shape = (Dynamic::new(shape.0), Dynamic::new(shape.1));
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
unsafe {
|
2022-11-11 22:46:04 +08:00
|
|
|
let data = $ViewStorage::new_unchecked($data, start, shape);
|
2021-08-03 00:41:46 +08:00
|
|
|
Matrix::from_data_statically_unchecked(data)
|
2016-12-05 05:44:42 +08:00
|
|
|
}
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Slices this matrix starting at its component `(start.0, start.1)` and with
|
|
|
|
/// `(shape.0, shape.1)` components. Each row (resp. column) of the sliced matrix is
|
|
|
|
/// separated by `steps.0` (resp. `steps.1`) ignored rows (resp. columns) of the
|
|
|
|
/// original matrix.
|
|
|
|
#[inline]
|
2022-11-14 21:02:36 +08:00
|
|
|
#[deprecated = slice_deprecation_note!($view_with_steps)]
|
2020-11-14 01:34:33 +08:00
|
|
|
pub fn $slice_with_steps($me: $Me, start: (usize, usize), shape: (usize, usize), steps: (usize, usize))
|
2022-11-11 23:10:39 +08:00
|
|
|
-> $MatrixView<'_, T, Dynamic, Dynamic, Dynamic, Dynamic> {
|
2022-11-14 21:02:36 +08:00
|
|
|
$me.$view_with_steps(start, shape, steps)
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
/// Return a view of this matrix starting at its component `(start.0, start.1)` and with
|
|
|
|
/// `(shape.0, shape.1)` components. Each row (resp. column) of the matrix view is
|
|
|
|
/// separated by `steps.0` (resp. `steps.1`) ignored rows (resp. columns) of the
|
|
|
|
/// original matrix.
|
|
|
|
#[inline]
|
|
|
|
pub fn $view_with_steps($me: $Me, start: (usize, usize), shape: (usize, usize), steps: (usize, usize))
|
|
|
|
-> $MatrixView<'_, T, Dynamic, Dynamic, Dynamic, Dynamic> {
|
|
|
|
let shape = (Dynamic::new(shape.0), Dynamic::new(shape.1));
|
|
|
|
$me.$generic_view_with_steps(start, shape, steps)
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Slices this matrix starting at its component `(irow, icol)` and with `(R::dim(),
|
2022-11-14 21:02:36 +08:00
|
|
|
/// CView::dim())` consecutive components.
|
2020-11-14 01:34:33 +08:00
|
|
|
#[inline]
|
2022-11-14 21:02:36 +08:00
|
|
|
#[deprecated = slice_deprecation_note!($fixed_view)]
|
|
|
|
pub fn $fixed_slice<const RVIEW: usize, const CVIEW: usize>($me: $Me, irow: usize, icol: usize)
|
|
|
|
-> $MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, S::RStride, S::CStride> {
|
|
|
|
$me.$fixed_view(irow, icol)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return a view of this matrix starting at its component `(irow, icol)` and with `(R::dim(),
|
|
|
|
/// CView::dim())` consecutive components.
|
|
|
|
#[inline]
|
|
|
|
pub fn $fixed_view<const RVIEW: usize, const CVIEW: usize>($me: $Me, irow: usize, icol: usize)
|
|
|
|
-> $MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, S::RStride, S::CStride> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2022-11-14 21:42:23 +08:00
|
|
|
$me.assert_view_index((irow, icol), (RVIEW, CVIEW), (0, 0));
|
2022-11-14 21:02:36 +08:00
|
|
|
let shape = (Const::<RVIEW>, Const::<CVIEW>);
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
unsafe {
|
2022-11-11 22:46:04 +08:00
|
|
|
let data = $ViewStorage::new_unchecked($data, (irow, icol), shape);
|
2021-08-03 00:41:46 +08:00
|
|
|
Matrix::from_data_statically_unchecked(data)
|
2016-12-05 05:44:42 +08:00
|
|
|
}
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Slices this matrix starting at its component `(start.0, start.1)` and with
|
2022-11-14 21:02:36 +08:00
|
|
|
/// `(RVIEW, CVIEW)` components. Each row (resp. column) of the sliced
|
2020-11-14 01:34:33 +08:00
|
|
|
/// matrix is separated by `steps.0` (resp. `steps.1`) ignored rows (resp. columns) of
|
|
|
|
/// the original matrix.
|
|
|
|
#[inline]
|
2022-11-14 21:02:36 +08:00
|
|
|
#[deprecated = slice_deprecation_note!($fixed_view_with_steps)]
|
|
|
|
pub fn $fixed_slice_with_steps<const RVIEW: usize, const CVIEW: usize>($me: $Me, start: (usize, usize), steps: (usize, usize))
|
|
|
|
-> $MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, Dynamic, Dynamic> {
|
|
|
|
$me.$fixed_view_with_steps(start, steps)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns a view of this matrix starting at its component `(start.0, start.1)` and with
|
|
|
|
/// `(RVIEW, CVIEW)` components. Each row (resp. column) of the matrix view
|
|
|
|
/// is separated by `steps.0` (resp. `steps.1`) ignored rows (resp. columns) of
|
|
|
|
/// the original matrix.
|
|
|
|
#[inline]
|
|
|
|
pub fn $fixed_view_with_steps<const RVIEW: usize, const CVIEW: usize>($me: $Me, start: (usize, usize), steps: (usize, usize))
|
|
|
|
-> $MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, Dynamic, Dynamic> {
|
|
|
|
let shape = (Const::<RVIEW>, Const::<CVIEW>);
|
|
|
|
$me.$generic_view_with_steps(start, shape, steps)
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Creates a slice that may or may not have a fixed size and stride.
|
|
|
|
#[inline]
|
2022-11-14 21:02:36 +08:00
|
|
|
#[deprecated = slice_deprecation_note!($generic_view)]
|
|
|
|
pub fn $generic_slice<RView, CView>($me: $Me, start: (usize, usize), shape: (RView, CView))
|
|
|
|
-> $MatrixView<'_, T, RView, CView, S::RStride, S::CStride>
|
|
|
|
where RView: Dim,
|
|
|
|
CView: Dim {
|
|
|
|
$me.$generic_view(start, shape)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Creates a matrix view that may or may not have a fixed size and stride.
|
|
|
|
#[inline]
|
|
|
|
pub fn $generic_view<RView, CView>($me: $Me, start: (usize, usize), shape: (RView, CView))
|
|
|
|
-> $MatrixView<'_, T, RView, CView, S::RStride, S::CStride>
|
|
|
|
where RView: Dim,
|
|
|
|
CView: Dim {
|
2021-08-03 00:41:46 +08:00
|
|
|
|
2022-11-14 21:42:23 +08:00
|
|
|
$me.assert_view_index(start, (shape.0.value(), shape.1.value()), (0, 0));
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
unsafe {
|
2022-11-11 22:46:04 +08:00
|
|
|
let data = $ViewStorage::new_unchecked($data, start, shape);
|
2021-08-03 00:41:46 +08:00
|
|
|
Matrix::from_data_statically_unchecked(data)
|
2016-12-05 05:44:42 +08:00
|
|
|
}
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// Creates a slice that may or may not have a fixed size and stride.
|
|
|
|
#[inline]
|
2022-11-14 21:02:36 +08:00
|
|
|
#[deprecated = slice_deprecation_note!($generic_view_with_steps)]
|
|
|
|
pub fn $generic_slice_with_steps<RView, CView>($me: $Me,
|
|
|
|
start: (usize, usize),
|
|
|
|
shape: (RView, CView),
|
|
|
|
steps: (usize, usize))
|
|
|
|
-> $MatrixView<'_, T, RView, CView, Dynamic, Dynamic>
|
|
|
|
where RView: Dim,
|
|
|
|
CView: Dim {
|
|
|
|
$me.$generic_view_with_steps(start, shape, steps)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Creates a matrix view that may or may not have a fixed size and stride.
|
|
|
|
#[inline]
|
|
|
|
pub fn $generic_view_with_steps<RView, CView>($me: $Me,
|
2020-11-14 01:34:33 +08:00
|
|
|
start: (usize, usize),
|
2022-11-14 21:02:36 +08:00
|
|
|
shape: (RView, CView),
|
2020-11-14 01:34:33 +08:00
|
|
|
steps: (usize, usize))
|
2022-11-14 21:02:36 +08:00
|
|
|
-> $MatrixView<'_, T, RView, CView, Dynamic, Dynamic>
|
|
|
|
where RView: Dim,
|
|
|
|
CView: Dim {
|
2020-11-14 01:34:33 +08:00
|
|
|
|
2022-11-14 21:42:23 +08:00
|
|
|
$me.assert_view_index(start, (shape.0.value(), shape.1.value()), steps);
|
2020-11-14 01:34:33 +08:00
|
|
|
|
|
|
|
let my_strides = $me.data.strides();
|
|
|
|
let strides = (Dynamic::new((steps.0 + 1) * my_strides.0.value()),
|
|
|
|
Dynamic::new((steps.1 + 1) * my_strides.1.value()));
|
|
|
|
|
|
|
|
unsafe {
|
2022-11-11 22:46:04 +08:00
|
|
|
let data = $ViewStorage::new_with_strides_unchecked($data, start, shape, strides);
|
2021-08-03 00:41:46 +08:00
|
|
|
Matrix::from_data_statically_unchecked(data)
|
2016-12-05 05:44:42 +08:00
|
|
|
}
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/*
|
|
|
|
*
|
|
|
|
* Splitting.
|
|
|
|
*
|
|
|
|
*/
|
2021-07-28 07:18:29 +08:00
|
|
|
/// Splits this `NxM` matrix into two parts delimited by two ranges.
|
2020-11-14 01:34:33 +08:00
|
|
|
///
|
|
|
|
/// Panics if the ranges overlap or if the first range is empty.
|
|
|
|
#[inline]
|
2022-11-14 21:47:43 +08:00
|
|
|
pub fn $rows_range_pair<Range1: DimRange<R>, Range2: DimRange<R>>($me: $Me, r1: Range1, r2: Range2)
|
2022-11-11 23:10:39 +08:00
|
|
|
-> ($MatrixView<'_, T, Range1::Size, C, S::RStride, S::CStride>,
|
|
|
|
$MatrixView<'_, T, Range2::Size, C, S::RStride, S::CStride>) {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
let (nrows, ncols) = $me.shape_generic();
|
2020-11-14 01:34:33 +08:00
|
|
|
let strides = $me.data.strides();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
let start1 = r1.begin(nrows);
|
|
|
|
let start2 = r2.begin(nrows);
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
let end1 = r1.end(nrows);
|
|
|
|
let end2 = r2.end(nrows);
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
let nrows1 = r1.size(nrows);
|
|
|
|
let nrows2 = r2.size(nrows);
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2022-11-14 21:40:53 +08:00
|
|
|
assert!(start2 >= end1 || start1 >= end2, "Rows range pair: the ranges must not overlap.");
|
2020-11-14 01:34:33 +08:00
|
|
|
assert!(end2 <= nrows.value(), "Rows range pair: index out of range.");
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
unsafe {
|
|
|
|
let ptr1 = $data.$get_addr(start1, 0);
|
|
|
|
let ptr2 = $data.$get_addr(start2, 0);
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2022-11-11 22:46:04 +08:00
|
|
|
let data1 = $ViewStorage::from_raw_parts(ptr1, (nrows1, ncols), strides);
|
|
|
|
let data2 = $ViewStorage::from_raw_parts(ptr2, (nrows2, ncols), strides);
|
2022-11-14 21:02:36 +08:00
|
|
|
let view1 = Matrix::from_data_statically_unchecked(data1);
|
|
|
|
let view2 = Matrix::from_data_statically_unchecked(data2);
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
(view1, view2)
|
2017-08-03 01:37:44 +08:00
|
|
|
}
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2021-07-28 07:18:29 +08:00
|
|
|
/// Splits this `NxM` matrix into two parts delimited by two ranges.
|
2020-11-14 01:34:33 +08:00
|
|
|
///
|
|
|
|
/// Panics if the ranges overlap or if the first range is empty.
|
|
|
|
#[inline]
|
2022-11-14 21:47:43 +08:00
|
|
|
pub fn $columns_range_pair<Range1: DimRange<C>, Range2: DimRange<C>>($me: $Me, r1: Range1, r2: Range2)
|
2022-11-11 23:10:39 +08:00
|
|
|
-> ($MatrixView<'_, T, R, Range1::Size, S::RStride, S::CStride>,
|
|
|
|
$MatrixView<'_, T, R, Range2::Size, S::RStride, S::CStride>) {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
let (nrows, ncols) = $me.shape_generic();
|
2020-11-14 01:34:33 +08:00
|
|
|
let strides = $me.data.strides();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
let start1 = r1.begin(ncols);
|
|
|
|
let start2 = r2.begin(ncols);
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
let end1 = r1.end(ncols);
|
|
|
|
let end2 = r2.end(ncols);
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
let ncols1 = r1.size(ncols);
|
|
|
|
let ncols2 = r2.size(ncols);
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2022-11-14 21:40:53 +08:00
|
|
|
assert!(start2 >= end1 || start1 >= end2, "Columns range pair: the ranges must not overlap.");
|
2020-11-14 01:34:33 +08:00
|
|
|
assert!(end2 <= ncols.value(), "Columns range pair: index out of range.");
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
unsafe {
|
|
|
|
let ptr1 = $data.$get_addr(0, start1);
|
|
|
|
let ptr2 = $data.$get_addr(0, start2);
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2022-11-11 22:46:04 +08:00
|
|
|
let data1 = $ViewStorage::from_raw_parts(ptr1, (nrows, ncols1), strides);
|
|
|
|
let data2 = $ViewStorage::from_raw_parts(ptr2, (nrows, ncols2), strides);
|
2022-11-14 21:02:36 +08:00
|
|
|
let view1 = Matrix::from_data_statically_unchecked(data1);
|
|
|
|
let view2 = Matrix::from_data_statically_unchecked(data2);
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
(view1, view2)
|
2017-08-03 01:37:44 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// A matrix slice.
|
2022-11-11 23:10:39 +08:00
|
|
|
///
|
|
|
|
/// This type alias exists only for legacy purposes and is deprecated. It will be removed
|
|
|
|
/// in a future release. Please use [`MatrixView`] instead.
|
|
|
|
/// See [issue #1076](https://github.com/dimforge/nalgebra/issues/1076)
|
|
|
|
/// for the rationale.
|
|
|
|
#[deprecated = "Use MatrixView instead."]
|
2021-04-11 17:00:38 +08:00
|
|
|
pub type MatrixSlice<'a, T, R, C, RStride = U1, CStride = R> =
|
2022-11-11 23:10:39 +08:00
|
|
|
MatrixView<'a, T, R, C, RStride, CStride>;
|
|
|
|
|
|
|
|
/// A matrix view.
|
|
|
|
pub type MatrixView<'a, T, R, C, RStride = U1, CStride = R> =
|
2022-11-11 22:46:04 +08:00
|
|
|
Matrix<T, R, C, ViewStorage<'a, T, R, C, RStride, CStride>>;
|
2022-11-11 23:10:39 +08:00
|
|
|
|
2020-11-14 01:34:33 +08:00
|
|
|
/// A mutable matrix slice.
|
2022-11-11 23:10:39 +08:00
|
|
|
///
|
|
|
|
/// This type alias exists only for legacy purposes and is deprecated. It will be removed
|
|
|
|
/// in a future release. Please use [`MatrixViewMut`] instead.
|
|
|
|
/// See [issue #1076](https://github.com/dimforge/nalgebra/issues/1076)
|
|
|
|
/// for the rationale.
|
|
|
|
#[deprecated = "Use MatrixViewMut instead."]
|
2021-04-11 17:00:38 +08:00
|
|
|
pub type MatrixSliceMut<'a, T, R, C, RStride = U1, CStride = R> =
|
2022-11-11 23:10:39 +08:00
|
|
|
MatrixViewMut<'a, T, R, C, RStride, CStride>;
|
|
|
|
|
|
|
|
/// A mutable matrix view.
|
|
|
|
pub type MatrixViewMut<'a, T, R, C, RStride = U1, CStride = R> =
|
2022-11-11 22:46:04 +08:00
|
|
|
Matrix<T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>;
|
2020-11-14 01:34:33 +08:00
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
/// # Views based on index and length
|
2021-08-03 00:41:46 +08:00
|
|
|
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
2022-11-14 21:02:36 +08:00
|
|
|
matrix_view_impl!(
|
2022-11-11 23:10:39 +08:00
|
|
|
self: &Self, MatrixView, ViewStorage, RawStorage.get_address_unchecked(), &self.data;
|
2016-12-05 05:44:42 +08:00
|
|
|
row,
|
2017-08-03 01:37:44 +08:00
|
|
|
row_part,
|
2016-12-05 05:44:42 +08:00
|
|
|
rows,
|
|
|
|
rows_with_step,
|
|
|
|
fixed_rows,
|
|
|
|
fixed_rows_with_step,
|
|
|
|
rows_generic,
|
2017-08-03 01:37:44 +08:00
|
|
|
rows_generic_with_step,
|
2016-12-05 05:44:42 +08:00
|
|
|
column,
|
2017-08-03 01:37:44 +08:00
|
|
|
column_part,
|
2016-12-05 05:44:42 +08:00
|
|
|
columns,
|
|
|
|
columns_with_step,
|
|
|
|
fixed_columns,
|
|
|
|
fixed_columns_with_step,
|
|
|
|
columns_generic,
|
2017-08-03 01:37:44 +08:00
|
|
|
columns_generic_with_step,
|
2022-11-14 21:02:36 +08:00
|
|
|
slice => view,
|
|
|
|
slice_with_steps => view_with_steps,
|
|
|
|
fixed_slice => fixed_view,
|
|
|
|
fixed_slice_with_steps => fixed_view_with_steps,
|
|
|
|
generic_slice => generic_view,
|
|
|
|
generic_slice_with_steps => generic_view_with_steps,
|
2017-08-03 01:37:44 +08:00
|
|
|
rows_range_pair,
|
|
|
|
columns_range_pair);
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
/// # Mutable views based on index and length
|
2021-08-03 00:41:46 +08:00
|
|
|
impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
|
2022-11-14 21:02:36 +08:00
|
|
|
matrix_view_impl!(
|
2022-11-11 23:10:39 +08:00
|
|
|
self: &mut Self, MatrixViewMut, ViewStorageMut, RawStorageMut.get_address_unchecked_mut(), &mut self.data;
|
2016-12-05 05:44:42 +08:00
|
|
|
row_mut,
|
2017-08-03 01:37:44 +08:00
|
|
|
row_part_mut,
|
2016-12-05 05:44:42 +08:00
|
|
|
rows_mut,
|
|
|
|
rows_with_step_mut,
|
|
|
|
fixed_rows_mut,
|
|
|
|
fixed_rows_with_step_mut,
|
|
|
|
rows_generic_mut,
|
2017-08-03 01:37:44 +08:00
|
|
|
rows_generic_with_step_mut,
|
2016-12-05 05:44:42 +08:00
|
|
|
column_mut,
|
2017-08-03 01:37:44 +08:00
|
|
|
column_part_mut,
|
2016-12-05 05:44:42 +08:00
|
|
|
columns_mut,
|
|
|
|
columns_with_step_mut,
|
|
|
|
fixed_columns_mut,
|
|
|
|
fixed_columns_with_step_mut,
|
|
|
|
columns_generic_mut,
|
2017-08-03 01:37:44 +08:00
|
|
|
columns_generic_with_step_mut,
|
2022-11-14 21:02:36 +08:00
|
|
|
slice_mut => view_mut,
|
|
|
|
slice_with_steps_mut => view_with_steps_mut,
|
|
|
|
fixed_slice_mut => fixed_view_mut,
|
|
|
|
fixed_slice_with_steps_mut => fixed_view_with_steps_mut,
|
|
|
|
generic_slice_mut => generic_view_mut,
|
|
|
|
generic_slice_with_steps_mut => generic_view_with_steps_mut,
|
2017-08-03 01:37:44 +08:00
|
|
|
rows_range_pair_mut,
|
|
|
|
columns_range_pair_mut);
|
2020-11-14 01:34:33 +08:00
|
|
|
}
|
2017-08-03 01:37:44 +08:00
|
|
|
|
2017-08-14 01:52:57 +08:00
|
|
|
/// A range with a size that may be known at compile-time.
|
|
|
|
///
|
|
|
|
/// This may be:
|
|
|
|
/// * A single `usize` index, e.g., `4`
|
|
|
|
/// * A left-open range `std::ops::RangeTo`, e.g., `.. 4`
|
|
|
|
/// * A right-open range `std::ops::RangeFrom`, e.g., `4 ..`
|
|
|
|
/// * A full range `std::ops::RangeFull`, e.g., `..`
|
2022-11-14 21:47:43 +08:00
|
|
|
pub trait DimRange<D: Dim> {
|
2017-08-14 01:52:57 +08:00
|
|
|
/// Type of the range size. May be a type-level integer.
|
2017-08-03 01:37:44 +08:00
|
|
|
type Size: Dim;
|
|
|
|
|
2017-08-14 01:52:57 +08:00
|
|
|
/// The start index of the range.
|
2017-08-03 01:37:44 +08:00
|
|
|
fn begin(&self, shape: D) -> usize;
|
2018-09-24 12:48:42 +08:00
|
|
|
// NOTE: this is the index immediately after the last index.
|
|
|
|
/// The index immediately after the last index inside of the range.
|
2017-08-03 01:37:44 +08:00
|
|
|
fn end(&self, shape: D) -> usize;
|
2017-08-14 01:52:57 +08:00
|
|
|
/// The number of elements of the range, i.e., `self.end - self.begin`.
|
2017-08-03 01:37:44 +08:00
|
|
|
fn size(&self, shape: D) -> Self::Size;
|
|
|
|
}
|
|
|
|
|
2022-11-14 21:47:43 +08:00
|
|
|
/// A range with a size that may be known at compile-time.
|
|
|
|
///
|
|
|
|
/// This is merely a legacy trait alias to minimize breakage. Use the [`DimRange`] trait instead.
|
|
|
|
#[deprecated = slice_deprecation_note!(DimRange)]
|
|
|
|
pub trait SliceRange<D: Dim>: DimRange<D> {}
|
|
|
|
|
|
|
|
#[allow(deprecated)]
|
|
|
|
impl<R: DimRange<D>, D: Dim> SliceRange<D> for R {}
|
|
|
|
|
|
|
|
impl<D: Dim> DimRange<D> for usize {
|
2017-08-03 01:37:44 +08:00
|
|
|
type Size = U1;
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn begin(&self, _: D) -> usize {
|
|
|
|
*self
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn end(&self, _: D) -> usize {
|
|
|
|
*self + 1
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn size(&self, _: D) -> Self::Size {
|
2021-01-03 22:20:34 +08:00
|
|
|
Const::<1>
|
2017-08-03 01:37:44 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-14 21:47:43 +08:00
|
|
|
impl<D: Dim> DimRange<D> for Range<usize> {
|
2017-08-03 01:37:44 +08:00
|
|
|
type Size = Dynamic;
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn begin(&self, _: D) -> usize {
|
|
|
|
self.start
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn end(&self, _: D) -> usize {
|
|
|
|
self.end
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn size(&self, _: D) -> Self::Size {
|
|
|
|
Dynamic::new(self.end - self.start)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-14 21:47:43 +08:00
|
|
|
impl<D: Dim> DimRange<D> for RangeFrom<usize> {
|
2017-08-03 01:37:44 +08:00
|
|
|
type Size = Dynamic;
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn begin(&self, _: D) -> usize {
|
|
|
|
self.start
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn end(&self, dim: D) -> usize {
|
|
|
|
dim.value()
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn size(&self, dim: D) -> Self::Size {
|
|
|
|
Dynamic::new(dim.value() - self.start)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-14 21:47:43 +08:00
|
|
|
impl<D: Dim> DimRange<D> for RangeTo<usize> {
|
2017-08-03 01:37:44 +08:00
|
|
|
type Size = Dynamic;
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn begin(&self, _: D) -> usize {
|
|
|
|
0
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn end(&self, _: D) -> usize {
|
|
|
|
self.end
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn size(&self, _: D) -> Self::Size {
|
|
|
|
Dynamic::new(self.end)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-14 21:47:43 +08:00
|
|
|
impl<D: Dim> DimRange<D> for RangeFull {
|
2017-08-03 01:37:44 +08:00
|
|
|
type Size = D;
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn begin(&self, _: D) -> usize {
|
|
|
|
0
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn end(&self, dim: D) -> usize {
|
|
|
|
dim.value()
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn size(&self, dim: D) -> Self::Size {
|
|
|
|
dim
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-14 21:47:43 +08:00
|
|
|
impl<D: Dim> DimRange<D> for RangeInclusive<usize> {
|
2021-06-17 15:42:47 +08:00
|
|
|
type Size = Dynamic;
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn begin(&self, _: D) -> usize {
|
|
|
|
*self.start()
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn end(&self, _: D) -> usize {
|
|
|
|
*self.end() + 1
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn size(&self, _: D) -> Self::Size {
|
|
|
|
Dynamic::new(*self.end() + 1 - *self.start())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-15 23:57:49 +08:00
|
|
|
// TODO: see how much of this overlaps with the general indexing
|
|
|
|
// methods from indexing.rs.
|
2021-08-03 00:41:46 +08:00
|
|
|
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
|
2017-08-14 01:52:57 +08:00
|
|
|
/// Slices a sub-matrix containing the rows indexed by the range `rows` and the columns indexed
|
|
|
|
/// by the range `cols`.
|
2017-08-03 01:37:44 +08:00
|
|
|
#[inline]
|
2021-06-07 22:34:03 +08:00
|
|
|
#[must_use]
|
2022-11-14 21:02:36 +08:00
|
|
|
#[deprecated = slice_deprecation_note!(view_range)]
|
2018-02-02 19:26:35 +08:00
|
|
|
pub fn slice_range<RowRange, ColRange>(
|
|
|
|
&self,
|
|
|
|
rows: RowRange,
|
|
|
|
cols: ColRange,
|
2022-11-11 23:10:39 +08:00
|
|
|
) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
|
2018-02-02 19:26:35 +08:00
|
|
|
where
|
2022-11-14 21:47:43 +08:00
|
|
|
RowRange: DimRange<R>,
|
|
|
|
ColRange: DimRange<C>,
|
2018-02-02 19:26:35 +08:00
|
|
|
{
|
2021-08-03 00:41:46 +08:00
|
|
|
let (nrows, ncols) = self.shape_generic();
|
2022-11-14 21:14:42 +08:00
|
|
|
self.generic_view(
|
2018-02-02 19:26:35 +08:00
|
|
|
(rows.begin(nrows), cols.begin(ncols)),
|
|
|
|
(rows.size(nrows), cols.size(ncols)),
|
|
|
|
)
|
2017-08-03 01:37:44 +08:00
|
|
|
}
|
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
/// Returns a view containing the rows indexed by the range `rows` and the columns indexed
|
|
|
|
/// by the range `cols`.
|
|
|
|
#[inline]
|
|
|
|
#[must_use]
|
|
|
|
pub fn view_range<RowRange, ColRange>(
|
|
|
|
&self,
|
|
|
|
rows: RowRange,
|
|
|
|
cols: ColRange,
|
|
|
|
) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
|
|
|
|
where
|
2022-11-14 21:47:43 +08:00
|
|
|
RowRange: DimRange<R>,
|
|
|
|
ColRange: DimRange<C>,
|
2022-11-14 21:02:36 +08:00
|
|
|
{
|
|
|
|
let (nrows, ncols) = self.shape_generic();
|
|
|
|
self.generic_view(
|
|
|
|
(rows.begin(nrows), cols.begin(ncols)),
|
|
|
|
(rows.size(nrows), cols.size(ncols)),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// View containing all the rows indexed by the range `rows`.
|
2017-08-03 01:37:44 +08:00
|
|
|
#[inline]
|
2021-06-07 22:34:03 +08:00
|
|
|
#[must_use]
|
2022-11-14 21:47:43 +08:00
|
|
|
pub fn rows_range<RowRange: DimRange<R>>(
|
2018-02-02 19:26:35 +08:00
|
|
|
&self,
|
|
|
|
rows: RowRange,
|
2022-11-11 23:10:39 +08:00
|
|
|
) -> MatrixView<'_, T, RowRange::Size, C, S::RStride, S::CStride> {
|
2022-11-14 21:02:36 +08:00
|
|
|
self.view_range(rows, ..)
|
2017-08-03 01:37:44 +08:00
|
|
|
}
|
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
/// View containing all the columns indexed by the range `rows`.
|
2017-08-03 01:37:44 +08:00
|
|
|
#[inline]
|
2021-06-07 22:34:03 +08:00
|
|
|
#[must_use]
|
2022-11-14 21:47:43 +08:00
|
|
|
pub fn columns_range<ColRange: DimRange<C>>(
|
2018-02-02 19:26:35 +08:00
|
|
|
&self,
|
|
|
|
cols: ColRange,
|
2022-11-11 23:10:39 +08:00
|
|
|
) -> MatrixView<'_, T, R, ColRange::Size, S::RStride, S::CStride> {
|
2022-11-14 21:02:36 +08:00
|
|
|
self.view_range(.., cols)
|
2017-08-03 01:37:44 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-15 23:57:49 +08:00
|
|
|
// TODO: see how much of this overlaps with the general indexing
|
|
|
|
// methods from indexing.rs.
|
2021-08-03 00:41:46 +08:00
|
|
|
impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S> {
|
2017-08-14 01:52:57 +08:00
|
|
|
/// Slices a mutable sub-matrix containing the rows indexed by the range `rows` and the columns
|
|
|
|
/// indexed by the range `cols`.
|
2022-11-14 21:02:36 +08:00
|
|
|
#[deprecated = slice_deprecation_note!(view_range_mut)]
|
2018-02-02 19:26:35 +08:00
|
|
|
pub fn slice_range_mut<RowRange, ColRange>(
|
|
|
|
&mut self,
|
|
|
|
rows: RowRange,
|
|
|
|
cols: ColRange,
|
2022-11-11 23:10:39 +08:00
|
|
|
) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
|
2018-02-02 19:26:35 +08:00
|
|
|
where
|
2022-11-14 21:47:43 +08:00
|
|
|
RowRange: DimRange<R>,
|
|
|
|
ColRange: DimRange<C>,
|
2022-11-14 21:02:36 +08:00
|
|
|
{
|
|
|
|
self.view_range_mut(rows, cols)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return a mutable view containing the rows indexed by the range `rows` and the columns
|
|
|
|
/// indexed by the range `cols`.
|
|
|
|
pub fn view_range_mut<RowRange, ColRange>(
|
|
|
|
&mut self,
|
|
|
|
rows: RowRange,
|
|
|
|
cols: ColRange,
|
|
|
|
) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
|
|
|
|
where
|
2022-11-14 21:47:43 +08:00
|
|
|
RowRange: DimRange<R>,
|
|
|
|
ColRange: DimRange<C>,
|
2018-02-02 19:26:35 +08:00
|
|
|
{
|
2021-08-03 00:41:46 +08:00
|
|
|
let (nrows, ncols) = self.shape_generic();
|
2022-11-14 21:02:36 +08:00
|
|
|
self.generic_view_mut(
|
2018-02-02 19:26:35 +08:00
|
|
|
(rows.begin(nrows), cols.begin(ncols)),
|
|
|
|
(rows.size(nrows), cols.size(ncols)),
|
|
|
|
)
|
2017-08-03 01:37:44 +08:00
|
|
|
}
|
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
/// Mutable view containing all the rows indexed by the range `rows`.
|
2017-08-03 01:37:44 +08:00
|
|
|
#[inline]
|
2022-11-14 21:47:43 +08:00
|
|
|
pub fn rows_range_mut<RowRange: DimRange<R>>(
|
2018-02-02 19:26:35 +08:00
|
|
|
&mut self,
|
|
|
|
rows: RowRange,
|
2022-11-11 23:10:39 +08:00
|
|
|
) -> MatrixViewMut<'_, T, RowRange::Size, C, S::RStride, S::CStride> {
|
2022-11-14 21:02:36 +08:00
|
|
|
self.view_range_mut(rows, ..)
|
2017-08-03 01:37:44 +08:00
|
|
|
}
|
|
|
|
|
2022-11-14 21:02:36 +08:00
|
|
|
/// Mutable view containing all the columns indexed by the range `cols`.
|
2017-08-03 01:37:44 +08:00
|
|
|
#[inline]
|
2022-11-14 21:47:43 +08:00
|
|
|
pub fn columns_range_mut<ColRange: DimRange<C>>(
|
2018-02-02 19:26:35 +08:00
|
|
|
&mut self,
|
|
|
|
cols: ColRange,
|
2022-11-11 23:10:39 +08:00
|
|
|
) -> MatrixViewMut<'_, T, R, ColRange::Size, S::RStride, S::CStride> {
|
2022-11-14 21:02:36 +08:00
|
|
|
self.view_range_mut(.., cols)
|
2017-08-03 01:37:44 +08:00
|
|
|
}
|
|
|
|
}
|
2019-01-28 18:22:57 +08:00
|
|
|
|
2022-11-11 23:10:39 +08:00
|
|
|
impl<'a, T, R, C, RStride, CStride> From<MatrixViewMut<'a, T, R, C, RStride, CStride>>
|
|
|
|
for MatrixView<'a, T, R, C, RStride, CStride>
|
2021-08-03 00:41:46 +08:00
|
|
|
where
|
|
|
|
R: Dim,
|
|
|
|
C: Dim,
|
|
|
|
RStride: Dim,
|
|
|
|
CStride: Dim,
|
2019-01-28 18:22:57 +08:00
|
|
|
{
|
2022-11-14 21:02:36 +08:00
|
|
|
fn from(view_mut: MatrixViewMut<'a, T, R, C, RStride, CStride>) -> Self {
|
2022-11-11 22:46:04 +08:00
|
|
|
let data = ViewStorage {
|
2022-11-14 21:02:36 +08:00
|
|
|
ptr: view_mut.data.ptr,
|
|
|
|
shape: view_mut.data.shape,
|
|
|
|
strides: view_mut.data.strides,
|
2019-01-28 18:22:57 +08:00
|
|
|
_phantoms: PhantomData,
|
|
|
|
};
|
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
unsafe { Matrix::from_data_statically_unchecked(data) }
|
2019-01-28 18:22:57 +08:00
|
|
|
}
|
2020-04-06 00:49:48 +08:00
|
|
|
}
|
2022-11-14 23:41:01 +08:00
|
|
|
|
|
|
|
impl<T, R, C, S> Matrix<T, R, C, S>
|
|
|
|
where
|
|
|
|
R: Dim,
|
|
|
|
C: Dim,
|
|
|
|
S: RawStorage<T, R, C>,
|
|
|
|
{
|
|
|
|
/// Returns this matrix as a view.
|
|
|
|
///
|
|
|
|
/// The returned view type is generally ambiguous unless specified.
|
|
|
|
/// This is particularly useful when working with functions or methods that take
|
|
|
|
/// matrix views as input.
|
|
|
|
///
|
|
|
|
/// # Panics
|
|
|
|
/// Panics if the dimensions of the view and the matrix are not compatible and this cannot
|
|
|
|
/// be proven at compile-time. This might happen, for example, when constructing a static
|
|
|
|
/// view of size 3x3 from a dynamically sized matrix of dimension 5x5.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
/// ```
|
|
|
|
/// use nalgebra::{DMatrixSlice, SMatrixView};
|
|
|
|
///
|
|
|
|
/// fn consume_view(_: DMatrixSlice<f64>) {}
|
|
|
|
///
|
|
|
|
/// let matrix = nalgebra::Matrix3::zeros();
|
|
|
|
/// consume_view(matrix.as_view());
|
|
|
|
///
|
|
|
|
/// let dynamic_view: DMatrixSlice<f64> = matrix.as_view();
|
|
|
|
/// let static_view_from_dyn: SMatrixView<f64, 3, 3> = dynamic_view.as_view();
|
|
|
|
/// ```
|
|
|
|
pub fn as_view<RView, CView, RViewStride, CViewStride>(&self) -> MatrixView<'_, T, RView, CView, RViewStride, CViewStride>
|
|
|
|
where
|
|
|
|
RView: Dim,
|
|
|
|
CView: Dim,
|
|
|
|
RViewStride: Dim,
|
|
|
|
CViewStride: Dim,
|
|
|
|
ShapeConstraint: DimEq<R, RView> + DimEq<C, CView> + DimEq<RViewStride, S::RStride> + DimEq<CViewStride, S::CStride>
|
|
|
|
{
|
|
|
|
// Defer to (&matrix).into()
|
|
|
|
self.into()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T, R, C, S> Matrix<T, R, C, S>
|
|
|
|
where
|
|
|
|
R: Dim,
|
|
|
|
C: Dim,
|
|
|
|
S: RawStorageMut<T, R, C>,
|
|
|
|
{
|
|
|
|
/// Returns this matrix as a mutable view.
|
|
|
|
///
|
|
|
|
/// The returned view type is generally ambiguous unless specified.
|
|
|
|
/// This is particularly useful when working with functions or methods that take
|
|
|
|
/// matrix views as input.
|
|
|
|
///
|
|
|
|
/// # Panics
|
|
|
|
/// Panics if the dimensions of the view and the matrix are not compatible and this cannot
|
|
|
|
/// be proven at compile-time. This might happen, for example, when constructing a static
|
|
|
|
/// view of size 3x3 from a dynamically sized matrix of dimension 5x5.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
/// ```
|
|
|
|
/// use nalgebra::{DMatrixViewMut, SMatrixViewMut};
|
|
|
|
///
|
|
|
|
/// fn consume_view(_: DMatrixViewMut<f64>) {}
|
|
|
|
///
|
|
|
|
/// let mut matrix = nalgebra::Matrix3::zeros();
|
|
|
|
/// consume_view(matrix.as_view_mut());
|
|
|
|
///
|
|
|
|
/// let mut dynamic_view: DMatrixViewMut<f64> = matrix.as_view_mut();
|
|
|
|
/// let static_view_from_dyn: SMatrixViewMut<f64, 3, 3> = dynamic_view.as_view_mut();
|
|
|
|
/// ```
|
|
|
|
pub fn as_view_mut<RView, CView, RViewStride, CViewStride>(&mut self) -> MatrixViewMut<'_, T, RView, CView, RViewStride, CViewStride>
|
|
|
|
where
|
|
|
|
RView: Dim,
|
|
|
|
CView: Dim,
|
|
|
|
RViewStride: Dim,
|
|
|
|
CViewStride: Dim,
|
|
|
|
ShapeConstraint: DimEq<R, RView> + DimEq<C, CView> + DimEq<RViewStride, S::RStride> + DimEq<CViewStride, S::CStride>
|
|
|
|
{
|
|
|
|
// Defer to (&mut matrix).into()
|
|
|
|
self.into()
|
|
|
|
}
|
|
|
|
}
|