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-08-03 00:41:46 +08:00
|
|
|
|
use crate::base::allocator::Allocator;
|
2020-04-06 00:49:48 +08:00
|
|
|
|
use crate::base::constraint::{SameNumberOfRows, ShapeConstraint};
|
2019-03-23 21:29:07 +08:00
|
|
|
|
use crate::base::default_allocator::DefaultAllocator;
|
|
|
|
|
use crate::base::dimension::{Dim, DimName, Dynamic, U1};
|
2021-08-03 00:41:46 +08:00
|
|
|
|
use crate::base::storage::{IsContiguous, Owned, RawStorage, RawStorageMut, ReshapableStorage};
|
|
|
|
|
use crate::base::{Scalar, Vector};
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
2021-05-07 00:15:49 +08:00
|
|
|
|
#[cfg(feature = "serde-serialize-no-std")]
|
|
|
|
|
use serde::{
|
|
|
|
|
de::{Deserialize, Deserializer, Error},
|
|
|
|
|
ser::{Serialize, Serializer},
|
|
|
|
|
};
|
|
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
|
use crate::Storage;
|
2021-08-03 16:59:03 +08:00
|
|
|
|
use std::mem::MaybeUninit;
|
2017-08-14 18:30:50 +08:00
|
|
|
|
|
2016-12-05 05:44:42 +08:00
|
|
|
|
/*
|
|
|
|
|
*
|
2021-08-03 00:41:46 +08:00
|
|
|
|
* RawStorage.
|
2016-12-05 05:44:42 +08:00
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
/// A Vec-based matrix data storage. It may be dynamically-sized.
|
2021-08-03 00:41:46 +08:00
|
|
|
|
#[repr(C)]
|
2017-02-16 05:04:34 +08:00
|
|
|
|
#[derive(Eq, Debug, Clone, PartialEq)]
|
2021-04-11 17:00:38 +08:00
|
|
|
|
pub struct VecStorage<T, R: Dim, C: Dim> {
|
2021-07-18 10:43:50 +08:00
|
|
|
|
data: Vec<T>,
|
2021-08-03 00:41:46 +08:00
|
|
|
|
nrows: R,
|
|
|
|
|
ncols: C,
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-07 00:15:49 +08:00
|
|
|
|
#[cfg(feature = "serde-serialize")]
|
|
|
|
|
impl<T, R: Dim, C: Dim> Serialize for VecStorage<T, R, C>
|
|
|
|
|
where
|
|
|
|
|
T: Serialize,
|
|
|
|
|
R: Serialize,
|
|
|
|
|
C: Serialize,
|
|
|
|
|
{
|
|
|
|
|
fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>
|
|
|
|
|
where
|
|
|
|
|
Ser: Serializer,
|
|
|
|
|
{
|
|
|
|
|
(&self.data, &self.nrows, &self.ncols).serialize(serializer)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[cfg(feature = "serde-serialize")]
|
|
|
|
|
impl<'a, T, R: Dim, C: Dim> Deserialize<'a> for VecStorage<T, R, C>
|
|
|
|
|
where
|
|
|
|
|
T: Deserialize<'a>,
|
|
|
|
|
R: Deserialize<'a>,
|
|
|
|
|
C: Deserialize<'a>,
|
|
|
|
|
{
|
|
|
|
|
fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
|
|
|
|
|
where
|
|
|
|
|
Des: Deserializer<'a>,
|
|
|
|
|
{
|
|
|
|
|
let (data, nrows, ncols): (Vec<T>, R, C) = Deserialize::deserialize(deserializer)?;
|
|
|
|
|
|
|
|
|
|
// SAFETY: make sure the data we deserialize have the
|
|
|
|
|
// correct number of elements.
|
|
|
|
|
if nrows.value() * ncols.value() != data.len() {
|
|
|
|
|
return Err(Des::Error::custom(format!(
|
|
|
|
|
"Expected {} components, found {}",
|
|
|
|
|
nrows.value() * ncols.value(),
|
|
|
|
|
data.len()
|
|
|
|
|
)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Ok(Self { data, nrows, ncols })
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-06 00:49:48 +08:00
|
|
|
|
#[deprecated(note = "renamed to `VecStorage`")]
|
2021-07-28 07:18:29 +08:00
|
|
|
|
/// Renamed to [`VecStorage`].
|
2021-04-11 17:00:38 +08:00
|
|
|
|
pub type MatrixVec<T, R, C> = VecStorage<T, R, C>;
|
2018-12-06 05:46:17 +08:00
|
|
|
|
|
2021-04-11 17:00:38 +08:00
|
|
|
|
impl<T, R: Dim, C: Dim> VecStorage<T, R, C> {
|
2017-02-13 01:17:09 +08:00
|
|
|
|
/// Creates a new dynamic matrix data storage from the given vector and shape.
|
2016-12-05 05:44:42 +08:00
|
|
|
|
#[inline]
|
2021-04-11 17:00:38 +08:00
|
|
|
|
pub fn new(nrows: R, ncols: C, data: Vec<T>) -> Self {
|
2018-02-02 19:26:35 +08:00
|
|
|
|
assert!(
|
|
|
|
|
nrows.value() * ncols.value() == data.len(),
|
|
|
|
|
"Data storage buffer dimension mismatch."
|
|
|
|
|
);
|
2020-10-11 16:57:26 +08:00
|
|
|
|
Self { data, nrows, ncols }
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// The underlying data storage.
|
|
|
|
|
#[inline]
|
2021-06-07 22:34:03 +08:00
|
|
|
|
#[must_use]
|
2021-04-11 17:00:38 +08:00
|
|
|
|
pub fn as_vec(&self) -> &Vec<T> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
&self.data
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// The underlying mutable data storage.
|
|
|
|
|
///
|
2021-07-04 11:19:07 +08:00
|
|
|
|
/// # Safety
|
2019-02-03 18:47:23 +08:00
|
|
|
|
/// This is unsafe because this may cause UB if the size of the vector is changed
|
|
|
|
|
/// by the user.
|
2016-12-05 05:44:42 +08:00
|
|
|
|
#[inline]
|
2021-04-11 17:00:38 +08:00
|
|
|
|
pub unsafe fn as_vec_mut(&mut self) -> &mut Vec<T> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
&mut self.data
|
|
|
|
|
}
|
2017-08-03 01:37:44 +08:00
|
|
|
|
|
2018-09-24 12:48:42 +08:00
|
|
|
|
/// Resizes the underlying mutable data storage and unwraps it.
|
2017-08-03 01:37:44 +08:00
|
|
|
|
///
|
2021-07-04 11:19:07 +08:00
|
|
|
|
/// # Safety
|
2021-08-03 23:02:42 +08:00
|
|
|
|
/// - If `sz` is larger than the current size, additional elements are uninitialized.
|
|
|
|
|
/// - If `sz` is smaller than the current size, additional elements are truncated but **not** dropped.
|
|
|
|
|
/// It is the responsibility of the caller of this method to drop these elements.
|
2017-08-03 01:37:44 +08:00
|
|
|
|
#[inline]
|
2021-08-03 16:59:03 +08:00
|
|
|
|
pub unsafe fn resize(mut self, sz: usize) -> Vec<MaybeUninit<T>> {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
let len = self.len();
|
|
|
|
|
|
2021-08-03 23:02:42 +08:00
|
|
|
|
let new_data = if sz < len {
|
|
|
|
|
// Use `set_len` instead of `truncate` because we don’t want to
|
|
|
|
|
// drop the removed elements (it’s the caller’s responsibility).
|
|
|
|
|
self.data.set_len(sz);
|
2017-08-03 01:37:44 +08:00
|
|
|
|
self.data.shrink_to_fit();
|
2021-08-03 16:59:03 +08:00
|
|
|
|
|
|
|
|
|
// Safety:
|
|
|
|
|
// - MaybeUninit<T> has the same alignment and layout as T.
|
|
|
|
|
// - The length and capacity come from a valid vector.
|
|
|
|
|
Vec::from_raw_parts(
|
|
|
|
|
self.data.as_mut_ptr() as *mut MaybeUninit<T>,
|
|
|
|
|
self.data.len(),
|
|
|
|
|
self.data.capacity(),
|
|
|
|
|
)
|
2018-02-02 19:26:35 +08:00
|
|
|
|
} else {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
self.data.reserve_exact(sz - len);
|
|
|
|
|
|
2021-08-03 16:59:03 +08:00
|
|
|
|
// Safety:
|
|
|
|
|
// - MaybeUninit<T> has the same alignment and layout as T.
|
|
|
|
|
// - The length and capacity come from a valid vector.
|
|
|
|
|
let mut new_data = Vec::from_raw_parts(
|
|
|
|
|
self.data.as_mut_ptr() as *mut MaybeUninit<T>,
|
|
|
|
|
self.data.len(),
|
|
|
|
|
self.data.capacity(),
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
// Safety: we can set the length here because MaybeUninit is always assumed
|
|
|
|
|
// to be initialized.
|
|
|
|
|
new_data.set_len(sz);
|
|
|
|
|
new_data
|
2021-08-03 23:02:42 +08:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Avoid double-free by forgetting `self` because its data buffer has
|
|
|
|
|
// been transfered to `new_data`.
|
|
|
|
|
std::mem::forget(self);
|
|
|
|
|
new_data
|
2017-08-03 01:37:44 +08:00
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
2018-09-13 11:45:14 +08:00
|
|
|
|
/// The number of elements on the underlying vector.
|
2016-12-05 05:44:42 +08:00
|
|
|
|
#[inline]
|
2021-06-07 22:34:03 +08:00
|
|
|
|
#[must_use]
|
2018-09-13 11:45:14 +08:00
|
|
|
|
pub fn len(&self) -> usize {
|
|
|
|
|
self.data.len()
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
2020-11-19 19:24:26 +08:00
|
|
|
|
|
|
|
|
|
/// Returns true if the underlying vector contains no elements.
|
|
|
|
|
#[inline]
|
2021-06-07 22:34:03 +08:00
|
|
|
|
#[must_use]
|
2020-11-19 19:24:26 +08:00
|
|
|
|
pub fn is_empty(&self) -> bool {
|
|
|
|
|
self.len() == 0
|
|
|
|
|
}
|
2021-08-03 00:41:46 +08:00
|
|
|
|
|
|
|
|
|
/// A slice containing all the components stored in this storage in column-major order.
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn as_slice(&self) -> &[T] {
|
|
|
|
|
&self.data[..]
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// A mutable slice containing all the components stored in this storage in column-major order.
|
|
|
|
|
#[inline]
|
|
|
|
|
pub fn as_mut_slice(&mut self) -> &mut [T] {
|
|
|
|
|
&mut self.data[..]
|
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
|
|
|
|
|
2021-06-18 15:45:37 +08:00
|
|
|
|
impl<T, R: Dim, C: Dim> From<VecStorage<T, R, C>> for Vec<T> {
|
|
|
|
|
fn from(vec: VecStorage<T, R, C>) -> Self {
|
|
|
|
|
vec.data
|
2018-11-21 06:44:29 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-05 05:44:42 +08:00
|
|
|
|
/*
|
|
|
|
|
*
|
|
|
|
|
* Dynamic − Static
|
|
|
|
|
* Dynamic − Dynamic
|
|
|
|
|
*
|
|
|
|
|
*/
|
2021-08-03 00:41:46 +08:00
|
|
|
|
unsafe impl<T, C: Dim> RawStorage<T, Dynamic, C> for VecStorage<T, Dynamic, C> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
type RStride = U1;
|
|
|
|
|
type CStride = Dynamic;
|
|
|
|
|
|
|
|
|
|
#[inline]
|
2021-04-11 17:00:38 +08:00
|
|
|
|
fn ptr(&self) -> *const T {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
self.data.as_ptr()
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
fn shape(&self) -> (Dynamic, C) {
|
|
|
|
|
(self.nrows, self.ncols)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
fn strides(&self) -> (Self::RStride, Self::CStride) {
|
|
|
|
|
(Self::RStride::name(), self.nrows)
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
#[inline]
|
2021-07-09 00:12:43 +08:00
|
|
|
|
fn is_contiguous(&self) -> bool {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
true
|
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
|
|
|
|
#[inline]
|
2021-08-03 00:41:46 +08:00
|
|
|
|
unsafe fn as_slice_unchecked(&self) -> &[T] {
|
|
|
|
|
&self.data
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
2021-08-03 00:41:46 +08:00
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
|
unsafe impl<T: Scalar, C: Dim> Storage<T, Dynamic, C> for VecStorage<T, Dynamic, C>
|
|
|
|
|
where
|
|
|
|
|
DefaultAllocator: Allocator<T, Dynamic, C, Buffer = Self>,
|
|
|
|
|
{
|
2016-12-05 05:44:42 +08:00
|
|
|
|
#[inline]
|
2021-08-03 00:41:46 +08:00
|
|
|
|
fn into_owned(self) -> Owned<T, Dynamic, C>
|
2021-07-18 10:43:50 +08:00
|
|
|
|
where
|
2021-08-03 00:41:46 +08:00
|
|
|
|
DefaultAllocator: Allocator<T, Dynamic, C>,
|
2020-04-06 00:49:48 +08:00
|
|
|
|
{
|
2021-08-03 00:41:46 +08:00
|
|
|
|
self
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
|
|
|
|
|
2017-08-03 01:37:44 +08:00
|
|
|
|
#[inline]
|
2021-08-03 00:41:46 +08:00
|
|
|
|
fn clone_owned(&self) -> Owned<T, Dynamic, C>
|
|
|
|
|
where
|
|
|
|
|
DefaultAllocator: Allocator<T, Dynamic, C>,
|
|
|
|
|
{
|
|
|
|
|
self.clone()
|
2017-08-03 01:37:44 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
|
unsafe impl<T, R: DimName> RawStorage<T, R, Dynamic> for VecStorage<T, R, Dynamic> {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
type RStride = U1;
|
|
|
|
|
type CStride = R;
|
|
|
|
|
|
2016-12-05 05:44:42 +08:00
|
|
|
|
#[inline]
|
2021-04-11 17:00:38 +08:00
|
|
|
|
fn ptr(&self) -> *const T {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
self.data.as_ptr()
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
fn shape(&self) -> (R, Dynamic) {
|
|
|
|
|
(self.nrows, self.ncols)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
|
fn strides(&self) -> (Self::RStride, Self::CStride) {
|
|
|
|
|
(Self::RStride::name(), self.nrows)
|
|
|
|
|
}
|
2017-08-03 01:37:44 +08:00
|
|
|
|
|
|
|
|
|
#[inline]
|
2021-07-09 00:12:43 +08:00
|
|
|
|
fn is_contiguous(&self) -> bool {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
true
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
2021-08-03 00:41:46 +08:00
|
|
|
|
unsafe fn as_slice_unchecked(&self) -> &[T] {
|
|
|
|
|
&self.data
|
2017-08-03 01:37:44 +08:00
|
|
|
|
}
|
2021-08-03 00:41:46 +08:00
|
|
|
|
}
|
2017-08-03 01:37:44 +08:00
|
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
|
unsafe impl<T: Scalar, R: DimName> Storage<T, R, Dynamic> for VecStorage<T, R, Dynamic>
|
|
|
|
|
where
|
|
|
|
|
DefaultAllocator: Allocator<T, R, Dynamic, Buffer = Self>,
|
|
|
|
|
{
|
2017-08-03 01:37:44 +08:00
|
|
|
|
#[inline]
|
2021-08-03 00:41:46 +08:00
|
|
|
|
fn into_owned(self) -> Owned<T, R, Dynamic>
|
2021-07-18 10:43:50 +08:00
|
|
|
|
where
|
2021-08-03 00:41:46 +08:00
|
|
|
|
DefaultAllocator: Allocator<T, R, Dynamic>,
|
2020-04-06 00:49:48 +08:00
|
|
|
|
{
|
2021-08-03 00:41:46 +08:00
|
|
|
|
self
|
2017-08-03 01:37:44 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
2021-08-03 00:41:46 +08:00
|
|
|
|
fn clone_owned(&self) -> Owned<T, R, Dynamic>
|
|
|
|
|
where
|
|
|
|
|
DefaultAllocator: Allocator<T, R, Dynamic>,
|
|
|
|
|
{
|
|
|
|
|
self.clone()
|
2017-08-03 01:37:44 +08:00
|
|
|
|
}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
*
|
2021-08-03 00:41:46 +08:00
|
|
|
|
* RawStorageMut, ContiguousStorage.
|
2016-12-05 05:44:42 +08:00
|
|
|
|
*
|
|
|
|
|
*/
|
2021-08-03 00:41:46 +08:00
|
|
|
|
unsafe impl<T, C: Dim> RawStorageMut<T, Dynamic, C> for VecStorage<T, Dynamic, C> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
#[inline]
|
2021-04-11 17:00:38 +08:00
|
|
|
|
fn ptr_mut(&mut self) -> *mut T {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
self.data.as_mut_ptr()
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
2021-06-17 15:46:49 +08:00
|
|
|
|
unsafe fn as_mut_slice_unchecked(&mut self) -> &mut [T] {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
&mut self.data[..]
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
|
unsafe impl<T, R: Dim, C: Dim> IsContiguous for VecStorage<T, R, C> {}
|
2016-12-05 05:44:42 +08:00
|
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
|
impl<T, C1, C2> ReshapableStorage<T, Dynamic, C1, Dynamic, C2> for VecStorage<T, Dynamic, C1>
|
|
|
|
|
where
|
|
|
|
|
T: Scalar,
|
|
|
|
|
C1: Dim,
|
|
|
|
|
C2: Dim,
|
2020-08-19 13:52:26 +08:00
|
|
|
|
{
|
2021-04-11 17:00:38 +08:00
|
|
|
|
type Output = VecStorage<T, Dynamic, C2>;
|
2020-08-19 13:52:26 +08:00
|
|
|
|
|
|
|
|
|
fn reshape_generic(self, nrows: Dynamic, ncols: C2) -> Self::Output {
|
|
|
|
|
assert_eq!(nrows.value() * ncols.value(), self.data.len());
|
|
|
|
|
VecStorage {
|
|
|
|
|
data: self.data,
|
|
|
|
|
nrows,
|
|
|
|
|
ncols,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
|
impl<T, C1, R2> ReshapableStorage<T, Dynamic, C1, R2, Dynamic> for VecStorage<T, Dynamic, C1>
|
|
|
|
|
where
|
|
|
|
|
T: Scalar,
|
|
|
|
|
C1: Dim,
|
|
|
|
|
R2: DimName,
|
2020-08-19 13:52:26 +08:00
|
|
|
|
{
|
2021-04-11 17:00:38 +08:00
|
|
|
|
type Output = VecStorage<T, R2, Dynamic>;
|
2020-08-19 13:52:26 +08:00
|
|
|
|
|
|
|
|
|
fn reshape_generic(self, nrows: R2, ncols: Dynamic) -> Self::Output {
|
|
|
|
|
assert_eq!(nrows.value() * ncols.value(), self.data.len());
|
|
|
|
|
VecStorage {
|
|
|
|
|
data: self.data,
|
|
|
|
|
nrows,
|
|
|
|
|
ncols,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
|
unsafe impl<T, R: DimName> RawStorageMut<T, R, Dynamic> for VecStorage<T, R, Dynamic> {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
#[inline]
|
2021-04-11 17:00:38 +08:00
|
|
|
|
fn ptr_mut(&mut self) -> *mut T {
|
2017-08-03 01:37:44 +08:00
|
|
|
|
self.data.as_mut_ptr()
|
2016-12-05 05:44:42 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[inline]
|
2021-06-17 15:46:49 +08:00
|
|
|
|
unsafe fn as_mut_slice_unchecked(&mut self) -> &mut [T] {
|
2016-12-05 05:44:42 +08:00
|
|
|
|
&mut self.data[..]
|
|
|
|
|
}
|
|
|
|
|
}
|
2017-08-14 18:30:50 +08:00
|
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
|
impl<T, R1, C2> ReshapableStorage<T, R1, Dynamic, Dynamic, C2> for VecStorage<T, R1, Dynamic>
|
|
|
|
|
where
|
|
|
|
|
T: Scalar,
|
|
|
|
|
R1: DimName,
|
|
|
|
|
C2: Dim,
|
2020-08-19 13:52:26 +08:00
|
|
|
|
{
|
2021-04-11 17:00:38 +08:00
|
|
|
|
type Output = VecStorage<T, Dynamic, C2>;
|
2020-08-19 13:52:26 +08:00
|
|
|
|
|
|
|
|
|
fn reshape_generic(self, nrows: Dynamic, ncols: C2) -> Self::Output {
|
|
|
|
|
assert_eq!(nrows.value() * ncols.value(), self.data.len());
|
|
|
|
|
VecStorage {
|
|
|
|
|
data: self.data,
|
|
|
|
|
nrows,
|
|
|
|
|
ncols,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
|
impl<T, R1, R2> ReshapableStorage<T, R1, Dynamic, R2, Dynamic> for VecStorage<T, R1, Dynamic>
|
|
|
|
|
where
|
|
|
|
|
T: Scalar,
|
|
|
|
|
R1: DimName,
|
|
|
|
|
R2: DimName,
|
2020-08-19 13:52:26 +08:00
|
|
|
|
{
|
2021-04-11 17:00:38 +08:00
|
|
|
|
type Output = VecStorage<T, R2, Dynamic>;
|
2020-08-19 13:52:26 +08:00
|
|
|
|
|
|
|
|
|
fn reshape_generic(self, nrows: R2, ncols: Dynamic) -> Self::Output {
|
|
|
|
|
assert_eq!(nrows.value() * ncols.value(), self.data.len());
|
|
|
|
|
VecStorage {
|
|
|
|
|
data: self.data,
|
|
|
|
|
nrows,
|
|
|
|
|
ncols,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-11 17:00:38 +08:00
|
|
|
|
impl<T, R: Dim> Extend<T> for VecStorage<T, R, Dynamic> {
|
2018-12-06 05:46:17 +08:00
|
|
|
|
/// Extends the number of columns of the `VecStorage` with elements
|
2018-11-11 07:02:52 +08:00
|
|
|
|
/// from the given iterator.
|
|
|
|
|
///
|
|
|
|
|
/// # Panics
|
|
|
|
|
/// This function panics if the number of elements yielded by the
|
|
|
|
|
/// given iterator is not a multiple of the number of rows of the
|
2018-12-06 05:46:17 +08:00
|
|
|
|
/// `VecStorage`.
|
2021-04-11 17:00:38 +08:00
|
|
|
|
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
|
2018-11-11 07:02:52 +08:00
|
|
|
|
self.data.extend(iter);
|
|
|
|
|
self.ncols = Dynamic::new(self.data.len() / self.nrows.value());
|
|
|
|
|
assert!(self.data.len() % self.nrows.value() == 0,
|
|
|
|
|
"The number of elements produced by the given iterator was not a multiple of the number of rows.");
|
|
|
|
|
}
|
|
|
|
|
}
|
2018-11-13 02:53:30 +08:00
|
|
|
|
|
2021-04-11 17:00:38 +08:00
|
|
|
|
impl<'a, T: 'a + Copy, R: Dim> Extend<&'a T> for VecStorage<T, R, Dynamic> {
|
2019-11-29 22:31:52 +08:00
|
|
|
|
/// Extends the number of columns of the `VecStorage` with elements
|
|
|
|
|
/// from the given iterator.
|
|
|
|
|
///
|
|
|
|
|
/// # Panics
|
|
|
|
|
/// This function panics if the number of elements yielded by the
|
|
|
|
|
/// given iterator is not a multiple of the number of rows of the
|
|
|
|
|
/// `VecStorage`.
|
2021-04-11 17:00:38 +08:00
|
|
|
|
fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
|
2019-11-29 22:31:52 +08:00
|
|
|
|
self.extend(iter.into_iter().copied())
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-03 00:41:46 +08:00
|
|
|
|
impl<T, R, RV, SV> Extend<Vector<T, RV, SV>> for VecStorage<T, R, Dynamic>
|
2018-11-14 05:17:00 +08:00
|
|
|
|
where
|
2021-08-03 00:41:46 +08:00
|
|
|
|
T: Scalar,
|
|
|
|
|
R: Dim,
|
|
|
|
|
RV: Dim,
|
|
|
|
|
SV: RawStorage<T, RV>,
|
2018-11-18 01:13:03 +08:00
|
|
|
|
ShapeConstraint: SameNumberOfRows<R, RV>,
|
2018-11-14 05:17:00 +08:00
|
|
|
|
{
|
2018-12-06 05:46:17 +08:00
|
|
|
|
/// Extends the number of columns of the `VecStorage` with vectors
|
2018-11-14 05:17:00 +08:00
|
|
|
|
/// from the given iterator.
|
|
|
|
|
///
|
|
|
|
|
/// # Panics
|
|
|
|
|
/// This function panics if the number of rows of each `Vector`
|
|
|
|
|
/// yielded by the iterator is not equal to the number of rows
|
2018-12-06 05:46:17 +08:00
|
|
|
|
/// of this `VecStorage`.
|
2021-04-11 17:00:38 +08:00
|
|
|
|
fn extend<I: IntoIterator<Item = Vector<T, RV, SV>>>(&mut self, iter: I) {
|
2018-11-14 05:17:00 +08:00
|
|
|
|
let nrows = self.nrows.value();
|
|
|
|
|
let iter = iter.into_iter();
|
|
|
|
|
let (lower, _upper) = iter.size_hint();
|
|
|
|
|
self.data.reserve(nrows * lower);
|
|
|
|
|
for vector in iter {
|
|
|
|
|
assert_eq!(nrows, vector.shape().0);
|
2019-12-06 06:54:17 +08:00
|
|
|
|
self.data.extend(vector.iter().cloned());
|
2018-11-14 05:17:00 +08:00
|
|
|
|
}
|
|
|
|
|
self.ncols = Dynamic::new(self.data.len() / nrows);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-11 17:00:38 +08:00
|
|
|
|
impl<T> Extend<T> for VecStorage<T, Dynamic, U1> {
|
2018-12-06 05:46:17 +08:00
|
|
|
|
/// Extends the number of rows of the `VecStorage` with elements
|
2018-11-13 02:53:30 +08:00
|
|
|
|
/// from the given iterator.
|
2021-04-11 17:00:38 +08:00
|
|
|
|
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
|
2018-11-13 02:53:30 +08:00
|
|
|
|
self.data.extend(iter);
|
|
|
|
|
self.nrows = Dynamic::new(self.data.len());
|
|
|
|
|
}
|
|
|
|
|
}
|