2017-02-13 01:17:09 +08:00
|
|
|
|
//! The default matrix data storage allocator.
|
|
|
|
|
//!
|
|
|
|
|
//! This will use stack-allocated buffers for matrices with dimensions known at compile-time, and
|
|
|
|
|
//! heap-allocated buffers for matrices with at least one dimension unknown at compile-time.
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
use std::cmp;
|
2018-05-19 23:15:15 +08:00
|
|
|
|
use std::mem;
|
|
|
|
|
use std::ptr;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
2018-05-24 23:17:34 +08:00
|
|
|
|
#[cfg(all(feature = "alloc", not(feature = "std")))]
|
2018-07-20 22:10:12 +08:00
|
|
|
|
use alloc::vec::Vec;
|
2018-05-24 23:17:34 +08:00
|
|
|
|
|
2021-01-03 22:20:34 +08:00
|
|
|
|
use super::Const;
|
2019-03-23 21:29:07 +08:00
|
|
|
|
use crate::base::allocator::{Allocator, Reallocator};
|
2020-04-06 00:49:48 +08:00
|
|
|
|
use crate::base::array_storage::ArrayStorage;
|
2018-05-27 03:02:24 +08:00
|
|
|
|
#[cfg(any(feature = "alloc", feature = "std"))]
|
2019-03-23 21:29:07 +08:00
|
|
|
|
use crate::base::dimension::Dynamic;
|
|
|
|
|
use crate::base::dimension::{Dim, DimName};
|
2020-04-06 00:49:48 +08:00
|
|
|
|
use crate::base::storage::{Storage, StorageMut};
|
2018-05-19 23:15:15 +08:00
|
|
|
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
2019-03-23 21:29:07 +08:00
|
|
|
|
use crate::base::vec_storage::VecStorage;
|
|
|
|
|
use crate::base::Scalar;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
*
|
|
|
|
|
* Allocator.
|
|
|
|
|
*
|
|
|
|
|
*/
|
2018-12-06 05:46:17 +08:00
|
|
|
|
/// An allocator based on `GenericArray` and `VecStorage` for statically-sized and dynamically-sized
|
2016-12-05 05:44:42 +08:00
|
|
|
|
/// matrices respectively.
|
|
|
|
|
pub struct DefaultAllocator;
|
|
|
|
|
|
|
|
|
|
// Static - Static
|
2021-01-03 22:20:34 +08:00
|
|
|
|
impl<N: Scalar, const R: usize, const C: usize> Allocator<N, Const<R>, Const<C>>
|
|
|
|
|
for DefaultAllocator
|
2018-02-02 19:26:35 +08:00
|
|
|
|
{
|
2018-12-06 05:40:03 +08:00
|
|
|
|
type Buffer = ArrayStorage<N, R, C>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
|
|
|
|
#[inline]
|
2020-11-27 12:25:36 +08:00
|
|
|
|
unsafe fn allocate_uninitialized(_: R, _: C) -> mem::MaybeUninit<Self::Buffer> {
|
|
|
|
|
mem::MaybeUninit::<Self::Buffer>::uninit()
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
2018-02-02 19:26:35 +08:00
|
|
|
|
fn allocate_from_iterator<I: IntoIterator<Item = N>>(
|
2021-01-03 22:20:34 +08:00
|
|
|
|
nrows: Const<R>,
|
|
|
|
|
ncols: Const<C>,
|
2018-02-02 19:26:35 +08:00
|
|
|
|
iter: I,
|
2020-04-06 00:49:48 +08:00
|
|
|
|
) -> Self::Buffer {
|
2020-11-28 05:00:48 +08:00
|
|
|
|
#[cfg(feature = "no_unsound_assume_init")]
|
2020-11-27 12:25:36 +08:00
|
|
|
|
let mut res: Self::Buffer = unimplemented!();
|
2020-11-28 05:00:48 +08:00
|
|
|
|
#[cfg(not(feature = "no_unsound_assume_init"))]
|
2020-11-27 12:25:36 +08:00
|
|
|
|
let mut res = unsafe { Self::allocate_uninitialized(nrows, ncols).assume_init() };
|
2016-12-05 05:44:42 +08:00
|
|
|
|
let mut count = 0;
|
|
|
|
|
|
2021-01-03 22:20:34 +08:00
|
|
|
|
for (res, e) in res.as_mut_slice().iter_mut().zip(iter.into_iter()) {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
*res = e;
|
|
|
|
|
count += 1;
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-02 19:26:35 +08:00
|
|
|
|
assert!(
|
|
|
|
|
count == nrows.value() * ncols.value(),
|
|
|
|
|
"Matrix init. from iterator: iterator not long enough."
|
|
|
|
|
);
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
|
|
|
|
res
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Dynamic - Static
|
|
|
|
|
// Dynamic - Dynamic
|
2018-05-19 23:15:15 +08:00
|
|
|
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
2019-12-17 07:09:14 +08:00
|
|
|
|
impl<N: Scalar, C: Dim> Allocator<N, Dynamic, C> for DefaultAllocator {
|
2018-12-06 05:46:17 +08:00
|
|
|
|
type Buffer = VecStorage<N, Dynamic, C>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
|
|
|
|
#[inline]
|
2020-11-27 12:25:36 +08:00
|
|
|
|
unsafe fn allocate_uninitialized(nrows: Dynamic, ncols: C) -> mem::MaybeUninit<Self::Buffer> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
let mut res = Vec::new();
|
|
|
|
|
let length = nrows.value() * ncols.value();
|
|
|
|
|
res.reserve_exact(length);
|
|
|
|
|
res.set_len(length);
|
|
|
|
|
|
2020-11-27 12:25:36 +08:00
|
|
|
|
mem::MaybeUninit::new(VecStorage::new(nrows, ncols, res))
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
2018-02-02 19:26:35 +08:00
|
|
|
|
fn allocate_from_iterator<I: IntoIterator<Item = N>>(
|
|
|
|
|
nrows: Dynamic,
|
|
|
|
|
ncols: C,
|
|
|
|
|
iter: I,
|
2020-04-06 00:49:48 +08:00
|
|
|
|
) -> Self::Buffer {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
let it = iter.into_iter();
|
|
|
|
|
let res: Vec<N> = it.collect();
|
|
|
|
|
assert!(res.len() == nrows.value() * ncols.value(),
|
|
|
|
|
"Allocation from iterator error: the iterator did not yield the correct number of elements.");
|
|
|
|
|
|
2018-12-06 05:46:17 +08:00
|
|
|
|
VecStorage::new(nrows, ncols, res)
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Static - Dynamic
|
2018-05-19 23:15:15 +08:00
|
|
|
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
2019-12-17 07:09:14 +08:00
|
|
|
|
impl<N: Scalar, R: DimName> Allocator<N, R, Dynamic> for DefaultAllocator {
|
2018-12-06 05:46:17 +08:00
|
|
|
|
type Buffer = VecStorage<N, R, Dynamic>;
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
|
|
|
|
#[inline]
|
2020-11-27 12:25:36 +08:00
|
|
|
|
unsafe fn allocate_uninitialized(nrows: R, ncols: Dynamic) -> mem::MaybeUninit<Self::Buffer> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
let mut res = Vec::new();
|
|
|
|
|
let length = nrows.value() * ncols.value();
|
|
|
|
|
res.reserve_exact(length);
|
|
|
|
|
res.set_len(length);
|
|
|
|
|
|
2020-11-27 12:25:36 +08:00
|
|
|
|
mem::MaybeUninit::new(VecStorage::new(nrows, ncols, res))
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
2018-02-02 19:26:35 +08:00
|
|
|
|
fn allocate_from_iterator<I: IntoIterator<Item = N>>(
|
|
|
|
|
nrows: R,
|
|
|
|
|
ncols: Dynamic,
|
|
|
|
|
iter: I,
|
2020-04-06 00:49:48 +08:00
|
|
|
|
) -> Self::Buffer {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
let it = iter.into_iter();
|
|
|
|
|
let res: Vec<N> = it.collect();
|
|
|
|
|
assert!(res.len() == nrows.value() * ncols.value(),
|
|
|
|
|
"Allocation from iterator error: the iterator did not yield the correct number of elements.");
|
|
|
|
|
|
2018-12-06 05:46:17 +08:00
|
|
|
|
VecStorage::new(nrows, ncols, res)
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
2017-08-03 01:37:44 +08:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
*
|
|
|
|
|
* Reallocator.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
// Anything -> Static × Static
|
2021-01-03 22:20:34 +08:00
|
|
|
|
impl<N: Scalar, RFrom, CFrom, const RTO: usize, const CTO: usize>
|
|
|
|
|
Reallocator<N, RFrom, CFrom, Const<RTO>, Const<CTO>> for DefaultAllocator
|
2018-02-02 19:26:35 +08:00
|
|
|
|
where
|
|
|
|
|
RFrom: Dim,
|
|
|
|
|
CFrom: Dim,
|
|
|
|
|
Self: Allocator<N, RFrom, CFrom>,
|
|
|
|
|
{
|
2017-08-03 01:37:44 +08:00
|
|
|
|
#[inline]
|
2018-02-02 19:26:35 +08:00
|
|
|
|
unsafe fn reallocate_copy(
|
2021-01-03 22:20:34 +08:00
|
|
|
|
rto: Const<RTO>,
|
|
|
|
|
cto: Const<CTO>,
|
2018-02-02 19:26:35 +08:00
|
|
|
|
buf: <Self as Allocator<N, RFrom, CFrom>>::Buffer,
|
2020-04-06 00:49:48 +08:00
|
|
|
|
) -> ArrayStorage<N, RTo, CTo> {
|
2020-11-28 05:00:48 +08:00
|
|
|
|
#[cfg(feature = "no_unsound_assume_init")]
|
2020-11-27 12:25:36 +08:00
|
|
|
|
let mut res: ArrayStorage<N, RTo, CTo> = unimplemented!();
|
2020-11-28 05:00:48 +08:00
|
|
|
|
#[cfg(not(feature = "no_unsound_assume_init"))]
|
|
|
|
|
let mut res =
|
|
|
|
|
<Self as Allocator<N, RTo, CTo>>::allocate_uninitialized(rto, cto).assume_init();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
|
|
|
|
|
let (rfrom, cfrom) = buf.shape();
|
|
|
|
|
|
|
|
|
|
let len_from = rfrom.value() * cfrom.value();
|
2018-02-02 19:26:35 +08:00
|
|
|
|
let len_to = rto.value() * cto.value();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
ptr::copy_nonoverlapping(buf.ptr(), res.ptr_mut(), cmp::min(len_from, len_to));
|
|
|
|
|
|
|
|
|
|
res
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Static × Static -> Dynamic × Any
|
2018-05-19 23:15:15 +08:00
|
|
|
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
2021-01-03 22:20:34 +08:00
|
|
|
|
impl<N: Scalar, CTo, const RFROM: usize, const CFROM: usize>
|
|
|
|
|
Reallocator<N, Const<RFROM>, Const<CFROM>, Dynamic, CTo> for DefaultAllocator
|
2018-02-02 19:26:35 +08:00
|
|
|
|
where
|
|
|
|
|
CTo: Dim,
|
|
|
|
|
{
|
2017-08-03 01:37:44 +08:00
|
|
|
|
#[inline]
|
2018-02-02 19:26:35 +08:00
|
|
|
|
unsafe fn reallocate_copy(
|
|
|
|
|
rto: Dynamic,
|
|
|
|
|
cto: CTo,
|
2021-01-03 22:20:34 +08:00
|
|
|
|
buf: ArrayStorage<N, RFROM, CFROM>,
|
2020-04-06 00:49:48 +08:00
|
|
|
|
) -> VecStorage<N, Dynamic, CTo> {
|
2020-11-28 05:00:48 +08:00
|
|
|
|
#[cfg(feature = "no_unsound_assume_init")]
|
2020-11-27 12:25:36 +08:00
|
|
|
|
let mut res: VecStorage<N, Dynamic, CTo> = unimplemented!();
|
2020-11-28 05:00:48 +08:00
|
|
|
|
#[cfg(not(feature = "no_unsound_assume_init"))]
|
|
|
|
|
let mut res =
|
|
|
|
|
<Self as Allocator<N, Dynamic, CTo>>::allocate_uninitialized(rto, cto).assume_init();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
|
|
|
|
|
let (rfrom, cfrom) = buf.shape();
|
|
|
|
|
|
|
|
|
|
let len_from = rfrom.value() * cfrom.value();
|
2018-02-02 19:26:35 +08:00
|
|
|
|
let len_to = rto.value() * cto.value();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
ptr::copy_nonoverlapping(buf.ptr(), res.ptr_mut(), cmp::min(len_from, len_to));
|
|
|
|
|
|
|
|
|
|
res
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Static × Static -> Static × Dynamic
|
2018-05-19 23:15:15 +08:00
|
|
|
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
2021-01-03 22:20:34 +08:00
|
|
|
|
impl<N: Scalar, RTo, const RFROM: usize, const CFROM: usize>
|
|
|
|
|
Reallocator<N, Const<RFROM>, Const<CFROM>, RTo, Dynamic> for DefaultAllocator
|
2018-02-02 19:26:35 +08:00
|
|
|
|
where
|
|
|
|
|
RTo: DimName,
|
|
|
|
|
{
|
2017-08-03 01:37:44 +08:00
|
|
|
|
#[inline]
|
2018-02-02 19:26:35 +08:00
|
|
|
|
unsafe fn reallocate_copy(
|
|
|
|
|
rto: RTo,
|
|
|
|
|
cto: Dynamic,
|
2021-01-03 22:20:34 +08:00
|
|
|
|
buf: ArrayStorage<N, RFROM, CFROM>,
|
2020-04-06 00:49:48 +08:00
|
|
|
|
) -> VecStorage<N, RTo, Dynamic> {
|
2020-11-28 05:00:48 +08:00
|
|
|
|
#[cfg(feature = "no_unsound_assume_init")]
|
2020-11-27 12:25:36 +08:00
|
|
|
|
let mut res: VecStorage<N, RTo, Dynamic> = unimplemented!();
|
2020-11-28 05:00:48 +08:00
|
|
|
|
#[cfg(not(feature = "no_unsound_assume_init"))]
|
|
|
|
|
let mut res =
|
|
|
|
|
<Self as Allocator<N, RTo, Dynamic>>::allocate_uninitialized(rto, cto).assume_init();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
|
|
|
|
|
let (rfrom, cfrom) = buf.shape();
|
|
|
|
|
|
|
|
|
|
let len_from = rfrom.value() * cfrom.value();
|
2018-02-02 19:26:35 +08:00
|
|
|
|
let len_to = rto.value() * cto.value();
|
2017-08-03 01:37:44 +08:00
|
|
|
|
ptr::copy_nonoverlapping(buf.ptr(), res.ptr_mut(), cmp::min(len_from, len_to));
|
|
|
|
|
|
|
|
|
|
res
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// All conversion from a dynamic buffer to a dynamic buffer.
|
2018-05-19 23:15:15 +08:00
|
|
|
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
2019-12-17 07:09:14 +08:00
|
|
|
|
impl<N: Scalar, CFrom: Dim, CTo: Dim> Reallocator<N, Dynamic, CFrom, Dynamic, CTo>
|
2018-05-19 23:15:15 +08:00
|
|
|
|
for DefaultAllocator
|
|
|
|
|
{
|
2017-08-03 01:37:44 +08:00
|
|
|
|
#[inline]
|
2018-02-02 19:26:35 +08:00
|
|
|
|
unsafe fn reallocate_copy(
|
|
|
|
|
rto: Dynamic,
|
|
|
|
|
cto: CTo,
|
2018-12-06 05:46:17 +08:00
|
|
|
|
buf: VecStorage<N, Dynamic, CFrom>,
|
2020-04-06 00:49:48 +08:00
|
|
|
|
) -> VecStorage<N, Dynamic, CTo> {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
let new_buf = buf.resize(rto.value() * cto.value());
|
2018-12-06 05:46:17 +08:00
|
|
|
|
VecStorage::new(rto, cto, new_buf)
|
2017-08-03 01:37:44 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-05-19 23:15:15 +08:00
|
|
|
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
2019-12-17 07:09:14 +08:00
|
|
|
|
impl<N: Scalar, CFrom: Dim, RTo: DimName> Reallocator<N, Dynamic, CFrom, RTo, Dynamic>
|
2018-05-19 23:15:15 +08:00
|
|
|
|
for DefaultAllocator
|
|
|
|
|
{
|
2017-08-03 01:37:44 +08:00
|
|
|
|
#[inline]
|
2018-02-02 19:26:35 +08:00
|
|
|
|
unsafe fn reallocate_copy(
|
|
|
|
|
rto: RTo,
|
|
|
|
|
cto: Dynamic,
|
2018-12-06 05:46:17 +08:00
|
|
|
|
buf: VecStorage<N, Dynamic, CFrom>,
|
2020-04-06 00:49:48 +08:00
|
|
|
|
) -> VecStorage<N, RTo, Dynamic> {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
let new_buf = buf.resize(rto.value() * cto.value());
|
2018-12-06 05:46:17 +08:00
|
|
|
|
VecStorage::new(rto, cto, new_buf)
|
2017-08-03 01:37:44 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-05-19 23:15:15 +08:00
|
|
|
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
2019-12-17 07:09:14 +08:00
|
|
|
|
impl<N: Scalar, RFrom: DimName, CTo: Dim> Reallocator<N, RFrom, Dynamic, Dynamic, CTo>
|
2018-05-19 23:15:15 +08:00
|
|
|
|
for DefaultAllocator
|
|
|
|
|
{
|
2017-08-03 01:37:44 +08:00
|
|
|
|
#[inline]
|
2018-02-02 19:26:35 +08:00
|
|
|
|
unsafe fn reallocate_copy(
|
|
|
|
|
rto: Dynamic,
|
|
|
|
|
cto: CTo,
|
2018-12-06 05:46:17 +08:00
|
|
|
|
buf: VecStorage<N, RFrom, Dynamic>,
|
2020-04-06 00:49:48 +08:00
|
|
|
|
) -> VecStorage<N, Dynamic, CTo> {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
let new_buf = buf.resize(rto.value() * cto.value());
|
2018-12-06 05:46:17 +08:00
|
|
|
|
VecStorage::new(rto, cto, new_buf)
|
2017-08-03 01:37:44 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-05-19 23:15:15 +08:00
|
|
|
|
#[cfg(any(feature = "std", feature = "alloc"))]
|
2019-12-17 07:09:14 +08:00
|
|
|
|
impl<N: Scalar, RFrom: DimName, RTo: DimName> Reallocator<N, RFrom, Dynamic, RTo, Dynamic>
|
2018-05-19 23:15:15 +08:00
|
|
|
|
for DefaultAllocator
|
|
|
|
|
{
|
2017-08-03 01:37:44 +08:00
|
|
|
|
#[inline]
|
2018-02-02 19:26:35 +08:00
|
|
|
|
unsafe fn reallocate_copy(
|
|
|
|
|
rto: RTo,
|
|
|
|
|
cto: Dynamic,
|
2018-12-06 05:46:17 +08:00
|
|
|
|
buf: VecStorage<N, RFrom, Dynamic>,
|
2020-04-06 00:49:48 +08:00
|
|
|
|
) -> VecStorage<N, RTo, Dynamic> {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
let new_buf = buf.resize(rto.value() * cto.value());
|
2018-12-06 05:46:17 +08:00
|
|
|
|
VecStorage::new(rto, cto, new_buf)
|
2017-08-03 01:37:44 +08:00
|
|
|
|
}
|
|
|
|
|
}
|