Struct Csl 

pub struct Csl<DS, IS, OS, const D: usize> { /* private fields */ }

Base structure for all CSL* variants.

It is possible to define your own fancy CSL.

type CustomCsl = ndstruct::Csl<
  Vec<num_bigint::BigNum, 32>,
  arrayvec::ArrayVec<[usize; 32]>,
  smallvec::SmallVec<[usize; 321]>,
  123
>

Types

• DA: Dimensions Array
• DS: Data Store
• IS: Indices Store
• OS: Offsets Store

Implementations

impl<DS, IS, OS, const D: usize> Csl<DS, IS, OS, D>

where DS: WithCapacity<Error = Error, Input = usize>, IS: WithCapacity<Error = Error, Input = usize>, OS: WithCapacity<Error = Error, Input = usize>,

pub fn with_capacity(nnz: usize, nolp1: usize) -> Result<Self>

Creates an empty instance with initial capacity.

For storages involving solely arrays, all arguments will be discarted.

Arguments

• nnz: Number of Non-Zero elements
• nolp1: Number Of Lines Plus 1, i.e., the dimensions product (without the innermost dimension) plus 1

Example

use ndstruct::csl::CslVec;
let dims = [11, 10, 1];
let nolp1 = dims.iter().rev().skip(1).product::<usize>() + 1;
let nnz = 2;
let _ = CslVec::<i32, 3>::with_capacity(nnz, nolp1);

impl<DS, IS, OS, const D: usize> Csl<DS, IS, OS, D>

pub fn dims(&self) -> &[usize; D]

The definitions of all dimensions.

Example

use ndstruct::doc_tests::csl_array_4;
assert_eq!(csl_array_4().dims(), &[2, 3, 4, 5]);

impl<DATA, DS, IS, OS, const D: usize> Csl<DS, IS, OS, D>

where DS: AsRef<[DATA]> + SingleTypeStorage<Item = DATA>, IS: AsRef<[usize]>, OS: AsRef<[usize]>,

pub fn new(dims: [usize; D], data: DS, indcs: IS, offs: OS) -> Result<Self>

Creates a valid CSL instance.

The compressed fields are a bit complex and unless you really know what you are doing, this method shouldn’t probably be used directly. Please, try to consider using [#constructor] instead.

Arguments

• dims: Array of dimensions
• data: Data collection
• indcs: Indices of each data item
• offs: Offset of each innermost line

Example

use ndstruct::csl::{CslArray, CslVec};
// Sparse array ([8, _, _, _, _, 9, _, _, _, _])
let mut _sparse_array = CslArray::new([10], [8.0, 9.0], [0, 5], [0, 2]);
// A bunch of nothing for your overflow needs
let mut _over_nine: ndstruct::Result<CslVec<(), 9001>>;
_over_nine = CslVec::new([0; 9001], vec![], vec![], vec![]);

pub fn data(&self) -> &[DATA]

The data that is being stored.

Example

use ndstruct::doc_tests::csl_array_4;
assert_eq!(csl_array_4().data(), &[1, 2, 3, 4, 5, 6, 7, 8, 9]);

pub fn indcs(&self) -> &[usize]

Indices (indcs) of a line, i.e., indices of the innermost dimension.

Example

use ndstruct::doc_tests::csl_array_4;
assert_eq!(csl_array_4().indcs(), &[0, 3, 1, 3, 4, 2, 2, 4, 2]);

pub fn line(&self, indcs: [usize; D]) -> Option<CslRef<'_, DATA, 1>>

Any immutable line reference determined by indcs. The innermost dimension is ignored.

Examples

use ndstruct::{csl::CslRef, doc_tests::csl_array_4};
let csl = csl_array_4();
assert_eq!(csl.line([0, 0, 2, 0]), CslRef::new([5], &[][..], &[][..], &[3, 3][..]).ok());
assert_eq!(csl.line([0, 1, 0, 0]), CslRef::new([5], &[6][..], &[2][..], &[5, 6][..]).ok());

pub fn nnz(&self) -> usize

Number of non zero elements.

Example

use ndstruct::doc_tests::csl_array_4;
assert_eq!(csl_array_4().nnz(), 9);

pub fn offs(&self) -> &[usize]

The joining of two consecutives offsets (offs) represent the starting and ending points of a line in the data and indcs slices.

Example

use ndstruct::doc_tests::csl_array_4;
assert_eq!(
  csl_array_4().offs(),
  &[0, 2, 3, 3, 5, 6, 6, 6, 6, 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9]
);

pub fn outermost_line_iter(&self) -> Result<CslLineIterRef<'_, DATA, D>>

Iterator that returns immutable line references of the outermost dimension

Examples

use ndstruct::{csl::CslRef, doc_tests::csl_array_4};
let csl = csl_array_4();
let sub_csl = csl.sub_dim(0..3).unwrap();
let mut iter = sub_csl.outermost_line_iter()?;
assert_eq!(
  iter.next(),
  CslRef::new([1, 4, 5], &[1, 2, 3, 4, 5][..], &[0, 3, 1, 3, 4][..], &[0, 2, 3, 3, 5][..]).ok()
);
assert_eq!(iter.next(), CslRef::new([1, 4, 5], &[6][..], &[2][..], &[5, 6, 6, 6, 6][..]).ok());
assert_eq!(
  iter.next(),
  CslRef::new([1, 4, 5], &[7, 8][..], &[2, 4][..], &[6, 7, 8, 8, 8][..]).ok()
);
assert_eq!(iter.next(), None);

pub fn outermost_line_rayon_iter( &self, ) -> Result<ParallelIteratorWrapper<CslLineIterRef<'_, DATA, D>>>

Parallel iterator that returns all immutable line references of the current dimension using rayon.

Examples

use ndstruct::doc_tests::csl_array_4;
use rayon::prelude::*;
let csl = csl_array_4();
let outermost_rayon_iter = csl.outermost_line_rayon_iter()?;
outermost_rayon_iter.enumerate().for_each(|(idx, csl_ref)| {
  assert_eq!(csl_ref, csl.outermost_line_iter().unwrap().nth(idx).unwrap());
});

pub fn sub_dim<const TD: usize>( &self, range: Range<usize>, ) -> Option<CslRef<'_, DATA, TD>>

Retrieves an immutable reference of any sub dimension.

Arguments

• range: Starting and ending of the desired dimension

Example

use ndstruct::{csl::CslRef, doc_tests::csl_array_4};
let csl = csl_array_4();
// The last cuboid
assert_eq!(
  csl.sub_dim(1..2),
  CslRef::new([1, 3, 4, 5], &[9][..], &[2][..], &[8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9][..])
    .ok()
);
// The last 2 matrices of the first cuboid;
assert_eq!(
  csl.sub_dim(1..3),
  CslRef::new([2, 4, 5], &[6, 7, 8][..], &[2, 2, 4][..], &[5, 6, 6, 6, 6, 7, 8, 8, 8][..]).ok()
);

pub fn value(&self, indcs: [usize; D]) -> Option<&DATA>

Retrieves an immutable reference of a single data value.

Arguments

• indcs: Indices of all dimensions

Example

use ndstruct::doc_tests::csl_array_4;
let csl = csl_array_4();
assert_eq!(csl.value([1, 0, 2, 2]), Some(&9));
let line = csl.line([0, 0, 3, 0]).unwrap();
assert_eq!(line.value([3]), Some(&4));

impl<DATA, DS, IS, OS, const D: usize> Csl<DS, IS, OS, D>

where DS: AsMut<[DATA]> + AsRef<[DATA]> + SingleTypeStorage<Item = DATA>, IS: AsRef<[usize]>, OS: AsRef<[usize]>,

pub fn clear(&mut self)

where DS: Clear, IS: Clear, OS: Clear,

Clears all values and dimensions.

Example

use ndstruct::{csl::CslVec, doc_tests::csl_vec_4};
let mut csl = csl_vec_4();
csl.clear();
assert_eq!(csl, CslVec::default());

pub fn constructor(&mut self) -> Result<CslLineConstructor<'_, DS, IS, OS, D>>

where DS: Push<DATA>, IS: Push<usize>, OS: Push<usize>,

See CslLineConstructor for more information.

pub fn data_mut(&mut self) -> &mut [DATA]

Mutable version of data.

pub fn line_mut(&mut self, indcs: [usize; D]) -> Option<CslMut<'_, DATA, 1>>

Mutable version of line.

pub fn outermost_line_iter_mut(&mut self) -> Result<CslLineIterMut<'_, DATA, D>>

Mutable version of outermost_line_iter.

pub fn outermost_line_rayon_iter_mut( &mut self, ) -> Result<ParallelIteratorWrapper<CslLineIterMut<'_, DATA, D>>>

Mutable version of outermost_line_rayon_iter.

pub fn sub_dim_mut<const TD: usize>( &mut self, range: Range<usize>, ) -> Option<CslMut<'_, DATA, TD>>

Mutable version of sub_dim.

pub fn swap_value(&mut self, a: [usize; D], b: [usize; D]) -> bool

Intra-swap a single data value.

Arguments

• a: First set of indices
• b: Second set of indices

Example

use ndstruct::doc_tests::csl_vec_4;
let mut csl = csl_vec_4();
csl.swap_value([0, 0, 0, 0], [1, 0, 2, 2]);
assert_eq!(csl.data(), &[9, 2, 3, 4, 5, 6, 7, 8, 1]);

pub fn truncate(&mut self, indcs: [usize; D])

where DS: Truncate<Input = usize>, IS: Truncate<Input = usize>, OS: AsMut<[usize]> + Truncate<Input = usize>,

Truncates all values in the exactly exclusive line defined by indcs. The last index is ignored.

Example

use ndstruct::{csl::CslVec, doc_tests::csl_vec_4};
let mut csl = csl_vec_4();
csl.truncate([0, 0, 3, 0]);
assert_eq!(
  Ok(csl),
  CslVec::new([0, 0, 4, 5], vec![1, 2, 3], vec![0, 3, 1], vec![0, 2, 3, 3, 3])
);

pub fn value_mut(&mut self, indcs: [usize; D]) -> Option<&mut DATA>

Mutable version of value.

impl<DATA, DS, IS, OS, const D: usize> Csl<DS, IS, OS, D>

where DS: AsMut<[DATA]> + AsRef<[DATA]> + Default + Push<DATA> + SingleTypeStorage<Item = DATA>, IS: AsMut<[usize]> + AsRef<[usize]> + Default + Push<usize>, OS: AsMut<[usize]> + AsRef<[usize]> + Default + Push<usize>,

pub fn new_controlled_random_rand<R>( dims: [usize; D], nnz: usize, rng: &mut R, cb: impl FnMut(&mut R, [usize; D]) -> DATA, ) -> Result<Self>

where R: Rng,

Creates a new random and valid instance delimited by the passed arguments.

Arguments

• dims: Array of dimensions
• nnz: Number of Non-Zero elements
• rng: rand::Rng trait
• cb: Callback to control data creation

Example

use ndstruct::csl::CslVec;
use rand::{Rng, rngs::mock::StepRng};
let mut rng = StepRng::new(0, 1);
let dims = [1, 2, 3];
let mut _random: ndstruct::Result<CslVec<u8, 3>>;
_random = CslVec::new_controlled_random_rand(dims, 9, &mut rng, |r, _| r.gen());

pub fn new_random_rand<R>(rng: &mut R, upper_bound: usize) -> Result<Self>

where R: Rng, StandardUniform: Distribution<DATA>,

Creates a new random and valid instance.

Arguments

• rng: rand::Rng trait
• upper_bound: The maximum allowed exclusive dimension

Trait Implementations

impl<DS: Clone, IS: Clone, OS: Clone, const D: usize> Clone for Csl<DS, IS, OS, D>

fn clone(&self) -> Csl<DS, IS, OS, D>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<DS: Debug, IS: Debug, OS: Debug, const D: usize> Debug for Csl<DS, IS, OS, D>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<DS: Default, IS: Default, OS: Default, const D: usize> Default for Csl<DS, IS, OS, D>

fn default() -> Csl<DS, IS, OS, D>

Returns the “default value” for a type.

impl<'de, DS, IS, OS, const D: usize> Deserialize<'de> for Csl<DS, IS, OS, D>

where DS: Deserialize<'de>, IS: Deserialize<'de>, OS: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<DS: Ord, IS: Ord, OS: Ord, const D: usize> Ord for Csl<DS, IS, OS, D>

fn cmp(&self, other: &Csl<DS, IS, OS, D>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<DS: PartialEq, IS: PartialEq, OS: PartialEq, const D: usize> PartialEq for Csl<DS, IS, OS, D>

fn eq(&self, other: &Csl<DS, IS, OS, D>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<DS: PartialOrd, IS: PartialOrd, OS: PartialOrd, const D: usize> PartialOrd for Csl<DS, IS, OS, D>

fn partial_cmp(&self, other: &Csl<DS, IS, OS, D>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<DS, IS, OS, const D: usize> Serialize for Csl<DS, IS, OS, D>

where DS: Serialize, IS: Serialize, OS: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<DS: Eq, IS: Eq, OS: Eq, const D: usize> Eq for Csl<DS, IS, OS, D>

impl<DS, IS, OS, const D: usize> StructuralPartialEq for Csl<DS, IS, OS, D>