Struct hassium::prelude::Grid2d

pub struct Grid2d<T> { /* fields omitted */ }

Methods

impl<T> Grid2d<T> where
    T: Clone + Send + Sync, 

pub fn new(cols: usize, rows: usize, fill: T) -> Grid2d<T>

pub fn with_cells(cols: usize, cells: Vec<T>) -> Grid2d<T>

pub fn resize(&mut self, cols: usize, rows: usize, default: T)

pub fn cols(&self) -> usize

pub fn rows(&self) -> usize

pub fn size(&self) -> (usize, usize)

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn cells(&self) -> &[T]

pub fn cells_mut(&mut self) -> &mut [T]

pub fn cell(&self, col: usize, row: usize) -> Option<&T>

pub fn cell_mut(&mut self, col: usize, row: usize) -> Option<&mut T>

pub fn get(&self, col: usize, row: usize) -> Option<T>

pub fn set(&mut self, col: usize, row: usize, value: T)

pub fn get_col_cells(&self, index: usize) -> Option<Vec<T>>

pub fn get_row_cells(&self, index: usize) -> Option<Vec<T>>

pub fn copy_part(&self, range: Range<(usize, usize)>, result: &mut Grid2d<T>) where
    T: Default, 

pub fn get_part(&self, range: Range<(usize, usize)>) -> Grid2d<T>

pub fn get_view(&self, range: Range<(usize, usize)>) -> Grid2d<&T>

pub fn copy_sample(&self, (usize, usize), margin: usize, result: &mut Grid2d<T>) where
    T: Default, 

pub fn sample(&self, (usize, usize), margin: usize) -> Grid2d<T>

pub fn view_sample(&self, (usize, usize), margin: usize) -> Grid2d<&T>

pub fn sin_map<F, R>(&self, f: F) -> Grid2d<R> where
    F: FnMut(usize, usize, &T) -> R,
    R: Clone + Send + Sync, 

pub fn map<F, R>(&self, f: F) -> Grid2d<R> where
    F: FnMut(usize, usize, &T) -> R + Clone + Send + Sync,
    R: Clone + Send + Sync, 

pub fn sin_with<F>(&mut self, f: F) where
    F: FnMut(usize, usize, &T) -> T, 

pub fn with<F>(&mut self, f: F) where
    F: FnMut(usize, usize, &T) -> T + Clone + Send + Sync, 

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

pub fn iter_view(
    &self,
    range: Range<(usize, usize)>
) -> impl Iterator<Item = (usize, usize, &T)>

pub fn iter_sample(
    &'a self,
    range: Range<(usize, usize)>,
    margin: usize
) -> impl Iterator<Item = (usize, usize, Grid2d<&'a T>)> + 'a

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>

pub fn iter_view_mut(
    &mut self,
    range: Range<(usize, usize)>
) -> impl Iterator<Item = (usize, usize, &mut T)>

pub fn neighbor_sample(&self, (usize, usize)) -> Grid2dNeighborSample<T> where
    T: Default + Copy, 

pub fn into_inner(self) -> (usize, usize, Vec<T>)

Trait Implementations

impl<T> Debug for Grid2d<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<'_, T> Sub<&'_ Grid2d<T>> for &'_ Grid2d<T> where
    T: Clone + Send + Sync + Sub<T, Output = T>, 

type Output = Result<Grid2d<T>, Grid2dError>

The resulting type after applying the - operator.

fn sub(self, other: &Grid2d<T>) -> <&'_ Grid2d<T> as Sub<&'_ Grid2d<T>>>::Output

Performs the - operation.

impl<'_, T> Mul<&'_ Grid2d<T>> for &'_ Grid2d<T> where
    T: Clone + Send + Sync + Mul<T, Output = T>, 

type Output = Result<Grid2d<T>, Grid2dError>

The resulting type after applying the * operator.

fn mul(self, other: &Grid2d<T>) -> <&'_ Grid2d<T> as Mul<&'_ Grid2d<T>>>::Output

Performs the * operation.

impl<T> Into<(usize, usize, Vec<T>)> for Grid2d<T> where
    T: Clone + Send + Sync, 

fn into(self) -> (usize, usize, Vec<T>)

Performs the conversion.

impl<T> Into<Vec<T>> for Grid2d<T> where
    T: Clone + Send + Sync, 

fn into(self) -> Vec<T>

Performs the conversion.

impl<'_, T> Neg for &'_ Grid2d<T> where
    T: Clone + Send + Sync + Neg<Output = T>, 

type Output = Grid2d<T>

The resulting type after applying the - operator.

fn neg(self) -> <&'_ Grid2d<T> as Neg>::Output

Performs the unary - operation.

impl<T> Serialize for Grid2d<T> where
    T: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<T> IntoIterator for Grid2d<T> where
    T: Clone + Send + Sync, 

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Grid2d<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> Index<(usize, usize)> for Grid2d<T> where
    T: Clone + Send + Sync, 

type Output = T

The returned type after indexing.

fn index(&self, (usize, usize)) -> &T

Performs the indexing (container[index]) operation.

impl<T> Index<[usize; 2]> for Grid2d<T> where
    T: Clone + Send + Sync, 

type Output = T

The returned type after indexing.

fn index(&self, [usize; 2]) -> &T

Performs the indexing (container[index]) operation.

impl<T> Clone for Grid2d<T> where
    T: Clone, 

fn clone(&self) -> Grid2d<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'_, T> Div<&'_ Grid2d<T>> for &'_ Grid2d<T> where
    T: Clone + Send + Sync + Div<T, Output = T>, 

type Output = Result<Grid2d<T>, Grid2dError>

The resulting type after applying the / operator.

fn div(self, other: &Grid2d<T>) -> <&'_ Grid2d<T> as Div<&'_ Grid2d<T>>>::Output

Performs the / operation.

impl<T> Default for Grid2d<T> where
    T: Default, 

fn default() -> Grid2d<T>

Returns the "default value" for a type.

impl<'de, T> Deserialize<'de> for Grid2d<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Grid2d<T>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'_, T> Add<&'_ Grid2d<T>> for &'_ Grid2d<T> where
    T: Clone + Send + Sync + Add<T, Output = T>, 

type Output = Result<Grid2d<T>, Grid2dError>

The resulting type after applying the + operator.

fn add(self, other: &Grid2d<T>) -> <&'_ Grid2d<T> as Add<&'_ Grid2d<T>>>::Output

Performs the + operation.

impl<I, T> From<(usize, I)> for Grid2d<T> where
    I: Iterator<Item = T>,
    T: Clone + Send + Sync, 

fn from((usize, I)) -> Grid2d<T>

Performs the conversion.

impl<T> IndexMut<(usize, usize)> for Grid2d<T> where
    T: Clone + Send + Sync, 

fn index_mut(&mut self, (usize, usize)) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T> IndexMut<[usize; 2]> for Grid2d<T> where
    T: Clone + Send + Sync, 

fn index_mut(&mut self, [usize; 2]) -> &mut T

Performs the mutable indexing (container[index]) operation.