Struct ConstantVec

pub struct ConstantVec<D, T, C = UnboundedCard<D>>
where
    D: Dim,
    T: Copy,
    C: Card<D>,
{ /* private fields */ }

A constant vector which returns the same value for any input index.

Example

use orx_v::*;

let v1 = V.d1().constant(42).bounded(4);

assert_eq!(v1.at([2]), 42);
assert_eq!(
    v1.equality(&[42, 42, 42, 42]),
    Equality::Equal
);

let v2 = V.d2().constant(42).with_rectangular_bounds([2, 3]);
assert_eq!(v2.at([0, 2]), 42);
assert_eq!(v2.at([1, 0]), 42);
assert_eq!(
    v2.equality(&vec![vec![42, 42, 42], vec![42, 42, 42]]),
    Equality::Equal
);

Implementations

impl<D, T, C> ConstantVec<D, T, C>

where D: Dim, T: Copy, C: Card<D>,

pub fn new(value: T, card: C) -> Self

Creates a new constant vector with the given card where all elements are equal to value.

Alternatively, unbounded constant vectors of different dimensions can be created by V.d1().constant(42), V.d2().constant(42), etc., which can later be transformed into bounded vectors by applying bounded, with_rectangular_bounds or with_variable_bounds transformations.

impl<T> ConstantVec<D1, T, UnboundedCard<D1>>

where T: Copy,

pub fn bounded(self, num_elements: usize) -> ConstantVec<D1, T, CardD1>

Transforms an unbounded constant vector into one with a fixed length.

Example

use orx_v::*;

let v1 = V.d1().constant(42);

assert_eq!(v1.card([]), usize::MAX);
assert_eq!(v1.at([2]), 42);
assert_eq!(v1.at([42]), 42);

let v1 = v1.bounded(4);
// or
let v1 = V.d1().constant(42).bounded(4);

assert_eq!(v1.card([]), 4);
assert_eq!(v1.at([2]), 42);
assert_eq!(v1.try_at([2]), Some(42));
assert_eq!(v1.try_at([42]), None);
assert_eq!(v1.all().collect::<Vec<_>>(), vec![42, 42, 42, 42]);

assert_eq!(v1.at([42]), 42); // (!) un-compromised performance

(!) un-compromised performance

Main reason to add bounds to a functional vector is to set its domain. However, calling at with an out-of-bounds index can still produce a valid element in order not to compromise performance. If we want to check whether or not an index is in bounds or not, we can use the in_bounds or card methods, or use try_at instead which would return None if the index is out of bounds.

impl<T> ConstantVec<D2, T, UnboundedCard<D2>>

where T: Copy,

pub fn with_rectangular_bounds( self, dimensions: [usize; 2], ) -> ConstantVec<D2, T, RectangularCardD2>

Transforms an unbounded constant vector into one with rectangular bounds as in matrices:

• the vector has dimensions[0] children, and
• each children has dimensions[1] elements.

Example

use orx_v::*;

let v2 = V.d2().constant(42).with_rectangular_bounds([2, 3]);

assert_eq!(v2.card([]), 2);
assert_eq!(v2.card([0]), 3);
assert_eq!(v2.card([1]), 3);
assert_eq!(v2.at([0, 2]), 42);
assert_eq!(v2.at([1, 0]), 42);
assert_eq!(
    v2.equality(&vec![vec![42, 42, 42], vec![42, 42, 42]]),
    Equality::Equal
);

assert_eq!(v2.try_at([42, 113]), None);
assert_eq!(v2.at([42, 113]), 42); // (!) un-compromised performance

(!) un-compromised performance

Main reason to add bounds to a functional vector is to set its domain. However, calling at with an out-of-bounds index can still produce a valid element in order not to compromise performance. If we want to check whether or not an index is in bounds or not, we can use the in_bounds or card methods, or use try_at instead which would return None if the index is out of bounds.

pub fn with_variable_bounds<C>( self, cardinality: C, ) -> ConstantVec<D2, T, VariableCardD2<C>>

where C: V1<usize>,

Transforms an unbounded constant vector into one with variable bounds as in jagged arrays:

• the vector has cardinality.card([]) children, and
• i-th child has cardinality.at([i]) elements.

Example

use orx_v::*;

// jagged => [ [42, 42], [42, 42, 42], [42] ]
let num_cols = vec![2, 3, 1];
let v2 = V.d2().constant(42).with_variable_bounds(&num_cols);

assert_eq!(v2.card([]), 3);
assert_eq!(v2.card([0]), 2);
assert_eq!(v2.card([1]), 3);
assert_eq!(v2.card([2]), 1);
assert_eq!(v2.at([1, 2]), 42);
assert_eq!(v2.at([2, 0]), 42);
assert_eq!(
    v2.equality(&vec![vec![42, 42], vec![42, 42, 42], vec![42]]),
    Equality::Equal
);

assert_eq!(v2.try_at([42, 113]), None);
assert_eq!(v2.at([42, 113]), 42); // (!) un-compromised performance

(!) un-compromised performance

Main reason to add bounds to a functional vector is to set its domain. However, calling at with an out-of-bounds index can still produce a valid element in order not to compromise performance. If we want to check whether or not an index is in bounds or not, we can use the in_bounds or card methods, or use try_at instead which would return None if the index is out of bounds.

impl<T> ConstantVec<D3, T, UnboundedCard<D3>>

where T: Copy,

pub fn with_rectangular_bounds( self, dimensions: [usize; 3], ) -> ConstantVec<D3, T, RectangularCardD3>

Transforms an unbounded constant vector into one with rectangular bounds as in multi-dimensional matrices. The matrix has dimensions[0] x dimensions[1] x dimensions[2] elements.

Example

use orx_v::*;

let v2 = V.d2().constant(42).with_rectangular_bounds([2, 3]);

assert_eq!(v2.card([]), 2);
assert_eq!(v2.card([0]), 3);
assert_eq!(v2.card([1]), 3);
assert_eq!(v2.at([0, 2]), 42);
assert_eq!(v2.at([1, 0]), 42);
assert_eq!(
    v2.equality(&vec![vec![42, 42, 42], vec![42, 42, 42]]),
    Equality::Equal
);

assert_eq!(v2.try_at([42, 113]), None);
assert_eq!(v2.at([42, 113]), 42); // (!) un-compromised performance

(!) un-compromised performance

Main reason to add bounds to a functional vector is to set its domain. However, calling at with an out-of-bounds index can still produce a valid element in order not to compromise performance. If we want to check whether or not an index is in bounds or not, we can use the in_bounds or card methods, or use try_at instead which would return None if the index is out of bounds.

pub fn with_variable_bounds<C>( self, cardinality: C, ) -> ConstantVec<D3, T, VariableCardD3<C>>

where C: V2<usize>,

Transforms an unbounded constant vector into one with variable bounds as in jagged arrays:

• the vector has cardinality.card([]) children, and
• i-th child has cardinality.at([i]) elements.

Example

use orx_v::*;

// jagged => [ [42, 42], [42, 42, 42], [42] ]
let num_cols = vec![2, 3, 1];
let v2 = V.d2().constant(42).with_variable_bounds(&num_cols);

assert_eq!(v2.card([]), 3);
assert_eq!(v2.card([0]), 2);
assert_eq!(v2.card([1]), 3);
assert_eq!(v2.card([2]), 1);
assert_eq!(v2.at([1, 2]), 42);
assert_eq!(v2.at([2, 0]), 42);
assert_eq!(
    v2.equality(&vec![vec![42, 42], vec![42, 42, 42], vec![42]]),
    Equality::Equal
);

assert_eq!(v2.try_at([42, 113]), None);
assert_eq!(v2.at([42, 113]), 42); // (!) un-compromised performance

(!) un-compromised performance

Main reason to add bounds to a functional vector is to set its domain. However, calling at with an out-of-bounds index can still produce a valid element in order not to compromise performance. If we want to check whether or not an index is in bounds or not, we can use the in_bounds or card methods, or use try_at instead which would return None if the index is out of bounds.

impl<T> ConstantVec<D4, T, UnboundedCard<D4>>

where T: Copy,

pub fn with_rectangular_bounds( self, dimensions: [usize; 4], ) -> ConstantVec<D4, T, RectangularCardD4>

Transforms an unbounded constant vector into one with rectangular bounds as in multi-dimensional matrices. The matrix has dimensions[0] x dimensions[1] x dimensions[2] x dimensions[3] elements.

Example

use orx_v::*;

let v2 = V.d2().constant(42).with_rectangular_bounds([2, 3]);

assert_eq!(v2.card([]), 2);
assert_eq!(v2.card([0]), 3);
assert_eq!(v2.card([1]), 3);
assert_eq!(v2.at([0, 2]), 42);
assert_eq!(v2.at([1, 0]), 42);
assert_eq!(
    v2.equality(&vec![vec![42, 42, 42], vec![42, 42, 42]]),
    Equality::Equal
);

assert_eq!(v2.try_at([42, 113]), None);
assert_eq!(v2.at([42, 113]), 42); // (!) un-compromised performance

(!) un-compromised performance

Main reason to add bounds to a functional vector is to set its domain. However, calling at with an out-of-bounds index can still produce a valid element in order not to compromise performance. If we want to check whether or not an index is in bounds or not, we can use the in_bounds or card methods, or use try_at instead which would return None if the index is out of bounds.

pub fn with_variable_bounds<C>( self, cardinality: C, ) -> ConstantVec<D4, T, VariableCardD4<C>>

where C: V3<usize>,

Transforms an unbounded constant vector into one with variable bounds as in jagged arrays:

• the vector has cardinality.card([]) children, and
• i-th child has cardinality.at([i]) elements.

Example

use orx_v::*;

// jagged => [ [42, 42], [42, 42, 42], [42] ]
let num_cols = vec![2, 3, 1];
let v2 = V.d2().constant(42).with_variable_bounds(&num_cols);

assert_eq!(v2.card([]), 3);
assert_eq!(v2.card([0]), 2);
assert_eq!(v2.card([1]), 3);
assert_eq!(v2.card([2]), 1);
assert_eq!(v2.at([1, 2]), 42);
assert_eq!(v2.at([2, 0]), 42);
assert_eq!(
    v2.equality(&vec![vec![42, 42], vec![42, 42, 42], vec![42]]),
    Equality::Equal
);

assert_eq!(v2.try_at([42, 113]), None);
assert_eq!(v2.at([42, 113]), 42); // (!) un-compromised performance

(!) un-compromised performance

Main reason to add bounds to a functional vector is to set its domain. However, calling at with an out-of-bounds index can still produce a valid element in order not to compromise performance. If we want to check whether or not an index is in bounds or not, we can use the in_bounds or card methods, or use try_at instead which would return None if the index is out of bounds.

Trait Implementations

impl<D, T, C> Clone for ConstantVec<D, T, C>

where D: Dim + Clone, T: Copy + Clone, C: Card<D> + Clone,

fn clone(&self) -> ConstantVec<D, T, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, C> Debug for ConstantVec<D1, T, C>

where T: Copy + Debug, C: Card<D1>,

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

Formats the value using the given formatter.

impl<T, C> Debug for ConstantVec<D2, T, C>

where T: Copy + Debug, C: Card<D2>,

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

Formats the value using the given formatter.

impl<T, C> Debug for ConstantVec<D3, T, C>

where T: Copy + Debug, C: Card<D3>,

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

Formats the value using the given formatter.

impl<T, C> Debug for ConstantVec<D4, T, C>

where T: Copy + Debug, C: Card<D4>,

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

Formats the value using the given formatter.

impl<D, T, C> NVec<D, T> for ConstantVec<D, T, C>

where D: Dim, T: Copy, C: Card<D>,

fn at(&self, _: impl IntoIdx<D>) -> T

Returns the element at the idx-th position of the vector.

fn child(&self, i: <D as Dim>::ChildIdx) -> impl NVec<<D as Dim>::PrevDim, T>

Returns the i-th child of the vector.

fn all(&self) -> impl Iterator<Item = T>

Returns a flattened iterator over all scalar (D0) elements of the vector.

fn num_children(&self) -> usize

Returns the number of children of the vector; i.e., number of elements of the one lower dimension.

fn card(&self, idx: impl Into<D::CardIdx>) -> usize

Returns the cardinality of the vec in any of the lower dimensions.

fn is_bounded(&self) -> bool

Returns whether or not the vector is bounded.

fn is_rectangular(&self) -> bool

Returns whether or not the cardinalities of the vector are rectangular. A rectangular vector of dimension D has the same number of children at a given lower dimension for all indices.

fn is_unbounded(&self) -> bool

Returns whether or not the vector is unbounded.

fn in_bounds(&self, idx: impl Into<D::LeqIdx>) -> bool

Returns whether or not the given idx is in bounds.

fn card_equality(&self, other: &impl NVec<D, T>) -> CardEquality<D>

Returns the cardinality equality of this vec with the other:

fn try_at(&self, idx: impl IntoIdx<D>) -> Option<T>

Returns the element at the idx-th position of the vector if the index is in_bounds; returns None otherwise.

fn equality(&self, other: &impl NVec<D, T>) -> Equality<D>

where T: PartialEq,

Returns the equality of this vec with the other:

fn children(&self) -> impl Iterator<Item = impl NVec<D::PrevDim, T>>

Returns an iterator of all children of the vector.

fn all_in( &self, indices: impl Iterator<Item = impl IntoIdx<D>>, ) -> impl Iterator<Item = T>

Returns an iterator of elements for the given indices.

impl<D, T, C> Copy for ConstantVec<D, T, C>

where D: Dim + Copy, T: Copy + Copy, C: Card<D> + Copy,