Struct MaskedCellBuffer 

pub struct MaskedCellBuffer(/* private fields */);

A CellBuffer with a companion Mask.

The Mask tracks which cells are valid across operations, and which should be treated as “no-data” values.

Example

use erased_cells::{BufferOps, Mask, MaskedCellBuffer};
// Fill a buffer with the `u16` numbers `0..=3` and mask [true, false, true, false].
let buf = MaskedCellBuffer::fill_with_mask_via(4, |i| (i as f64, i % 2 == 0));
assert_eq!(buf.mask(), &Mask::new(vec![true, false, true, false]));
// We can count the data/no-data values
assert_eq!(buf.counts(), (2, 2));

// Mask values are propagated across math operations.
let ones = MaskedCellBuffer::from_vec(vec![1.0; 4]);
let r = (buf + ones) * 2.0;

let expected = MaskedCellBuffer::new(
    vec![
        (0.0 + 1.0) * 2.0,
        (1.0 + 1.0) * 2.0,
        (2.0 + 1.0) * 2.0,
        (3.0 + 1.0) * 2.0,
    ]
    .into(),
    Mask::new(vec![true, false, true, false]),
);
assert_eq!(r, expected);

Implementations

impl MaskedCellBuffer

pub fn new(buffer: CellBuffer, mask: Mask) -> Self

Create a new combined CellBuffer and Mask.

Panics

Will panics if buffer and mask are not the same length.

Examples found in repository

examples/masked.rs (lines 13-22)

fn main() {
    use erased_cells::{BufferOps, Mask, MaskedCellBuffer};
    // Fill a buffer with the `u16` numbers `0..=3` and mask [true, false, true, false].
    let buf = MaskedCellBuffer::fill_with_mask_via(4, |i| (i as f64, i % 2 == 0));
    assert_eq!(buf.mask(), &Mask::new(vec![true, false, true, false]));
    // We can count the data/no-data values
    assert_eq!(buf.counts(), (2, 2));

    // Mask values are propagated across math operations.
    let ones = MaskedCellBuffer::from_vec(vec![1.0; 4]);
    let r = (buf + ones) * 2.0;
    let expected = MaskedCellBuffer::new(
        vec![
            (0.0 + 1.0) * 2.0,
            (1.0 + 1.0) * 2.0,
            (2.0 + 1.0) * 2.0,
            (3.0 + 1.0) * 2.0,
        ]
        .into(),
        Mask::new(vec![true, false, true, false]),
    );
    assert_eq!(r, expected);
}

pub fn from_vec_with_nodata<T: CellEncoding>( data: Vec<T>, nodata: NoData<T>, ) -> Self

Constructs a MaskedCellBuffer from a Vec<CellEncoding>, specifying a NoData<T> value.

Mask value will be false when associated cell matches nodata.

Use Self::from_vec

pub fn fill_with_mask_via<T, F>(len: usize, mv: F) -> Self

where T: CellEncoding, F: Fn(usize) -> (T, bool),

Examples found in repository

examples/masked.rs (line 5)

fn main() {
    use erased_cells::{BufferOps, Mask, MaskedCellBuffer};
    // Fill a buffer with the `u16` numbers `0..=3` and mask [true, false, true, false].
    let buf = MaskedCellBuffer::fill_with_mask_via(4, |i| (i as f64, i % 2 == 0));
    assert_eq!(buf.mask(), &Mask::new(vec![true, false, true, false]));
    // We can count the data/no-data values
    assert_eq!(buf.counts(), (2, 2));

    // Mask values are propagated across math operations.
    let ones = MaskedCellBuffer::from_vec(vec![1.0; 4]);
    let r = (buf + ones) * 2.0;
    let expected = MaskedCellBuffer::new(
        vec![
            (0.0 + 1.0) * 2.0,
            (1.0 + 1.0) * 2.0,
            (2.0 + 1.0) * 2.0,
            (3.0 + 1.0) * 2.0,
        ]
        .into(),
        Mask::new(vec![true, false, true, false]),
    );
    assert_eq!(r, expected);
}

pub fn buffer(&self) -> &CellBuffer

pub fn buffer_mut(&mut self) -> &mut CellBuffer

pub fn mask(&self) -> &Mask

Examples found in repository

examples/masked.rs (line 6)

fn main() {
    use erased_cells::{BufferOps, Mask, MaskedCellBuffer};
    // Fill a buffer with the `u16` numbers `0..=3` and mask [true, false, true, false].
    let buf = MaskedCellBuffer::fill_with_mask_via(4, |i| (i as f64, i % 2 == 0));
    assert_eq!(buf.mask(), &Mask::new(vec![true, false, true, false]));
    // We can count the data/no-data values
    assert_eq!(buf.counts(), (2, 2));

    // Mask values are propagated across math operations.
    let ones = MaskedCellBuffer::from_vec(vec![1.0; 4]);
    let r = (buf + ones) * 2.0;
    let expected = MaskedCellBuffer::new(
        vec![
            (0.0 + 1.0) * 2.0,
            (1.0 + 1.0) * 2.0,
            (2.0 + 1.0) * 2.0,
            (3.0 + 1.0) * 2.0,
        ]
        .into(),
        Mask::new(vec![true, false, true, false]),
    );
    assert_eq!(r, expected);
}

pub fn mask_mut(&mut self) -> &mut Mask

pub fn get_masked(&self, index: usize) -> Option<CellValue>

Get a buffer value at position index with mask evaluated.

Returns Some(CellValue) if mask at index is true, None otherwise.

pub fn get_with_mask(&self, index: usize) -> (CellValue, bool)

Get the cell value and mask value at position index.

Returns (CellValue, bool). If bool is false, associated CellValue should be considered invalid.

pub fn put_with_mask( &mut self, index: usize, value: CellValue, mask: bool, ) -> Result<()>

Set the value and mask at position index.

Returns Err(NarrowingError) if value cannot be converted to self.cell_type() without data loss (e.g. overflow).

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

Returns a tuple of representing counts of (data, nodata).

Examples found in repository

examples/masked.rs (line 8)

fn main() {
    use erased_cells::{BufferOps, Mask, MaskedCellBuffer};
    // Fill a buffer with the `u16` numbers `0..=3` and mask [true, false, true, false].
    let buf = MaskedCellBuffer::fill_with_mask_via(4, |i| (i as f64, i % 2 == 0));
    assert_eq!(buf.mask(), &Mask::new(vec![true, false, true, false]));
    // We can count the data/no-data values
    assert_eq!(buf.counts(), (2, 2));

    // Mask values are propagated across math operations.
    let ones = MaskedCellBuffer::from_vec(vec![1.0; 4]);
    let r = (buf + ones) * 2.0;
    let expected = MaskedCellBuffer::new(
        vec![
            (0.0 + 1.0) * 2.0,
            (1.0 + 1.0) * 2.0,
            (2.0 + 1.0) * 2.0,
            (3.0 + 1.0) * 2.0,
        ]
        .into(),
        Mask::new(vec![true, false, true, false]),
    );
    assert_eq!(r, expected);
}

pub fn to_vec_with_nodata<T: CellEncoding>( self, no_data: NoData<T>, ) -> Result<Vec<T>>

Convert self into a Vec<T>, replacing values where the mask is 0 to no_data.value()

Trait Implementations

impl Add<&MaskedCellBuffer> for MaskedCellBuffer

type Output = MaskedCellBuffer

The resulting type after applying the + operator.

fn add(self, rhs: &MaskedCellBuffer) -> Self::Output

Performs the + operation.

impl<R> Add<R> for MaskedCellBuffer

where R: Into<CellValue>,

type Output = MaskedCellBuffer

The resulting type after applying the + operator.

fn add(self, rhs: R) -> Self::Output

Performs the + operation.

impl Add for &MaskedCellBuffer

type Output = MaskedCellBuffer

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl Add for MaskedCellBuffer

type Output = MaskedCellBuffer

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl BufferOps for MaskedCellBuffer

fn to_vec<T: CellEncoding>(self) -> Result<Vec<T>>

Converts self to Vec<T>, ignoring the mask values.

See also: Self::to_vec_with_nodata and NoData.

fn from_vec<T: CellEncoding>(data: Vec<T>) -> Self

Construct a CellBuffer from a Vec<T>.

fn with_defaults(len: usize, ct: CellType) -> Self

Construct a CellBuffer of given len length and ct CellType

fn fill(len: usize, value: CellValue) -> Self

Create a buffer of size len with all values value.

fn fill_via<T, F>(len: usize, f: F) -> Self

where T: CellEncoding, F: Fn(usize) -> T,

Fill a buffer of size len with values from a closure.

fn len(&self) -> usize

Get the length of the buffer.

fn cell_type(&self) -> CellType

Get the cell type of the encoded value.

fn get(&self, index: usize) -> CellValue

Get the CellValue at index idx.

fn put(&mut self, idx: usize, value: CellValue) -> Result<()>

Store value at position idx.

fn convert(&self, cell_type: CellType) -> Result<Self>

where Self: Sized,

Create a new CellBuffer whereby all CellValues are converted to cell_type.

fn min_max(&self) -> (CellValue, CellValue)

Compute the minimum and maximum values the buffer.

fn is_empty(&self) -> bool

Determine if the buffer has zero values in it.

impl Clone for MaskedCellBuffer

fn clone(&self) -> MaskedCellBuffer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MaskedCellBuffer

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MaskedCellBuffer

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div<&MaskedCellBuffer> for MaskedCellBuffer

type Output = MaskedCellBuffer

The resulting type after applying the / operator.

fn div(self, rhs: &MaskedCellBuffer) -> Self::Output

Performs the / operation.

impl<R> Div<R> for MaskedCellBuffer

where R: Into<CellValue>,

type Output = MaskedCellBuffer

The resulting type after applying the / operator.

fn div(self, rhs: R) -> Self::Output

Performs the / operation.

impl Div for &MaskedCellBuffer

type Output = MaskedCellBuffer

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl Div for MaskedCellBuffer

type Output = MaskedCellBuffer

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<C: CellEncoding> Extend<(C, bool)> for MaskedCellBuffer

fn extend<T: IntoIterator<Item = (C, bool)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a> From<&'a MaskedCellBuffer> for (&'a CellBuffer, &'a Mask)

fn from(value: &'a MaskedCellBuffer) -> Self

Converts to this type from the input type.

impl From<CellBuffer> for MaskedCellBuffer

Converts a CellBuffer into a MaskedCellBuffer with an all-true mask.

fn from(value: CellBuffer) -> Self

Converts to this type from the input type.

impl From<MaskedCellBuffer> for (CellBuffer, Mask)

fn from(value: MaskedCellBuffer) -> Self

Converts to this type from the input type.

impl<C: CellEncoding> FromIterator<(C, bool)> for MaskedCellBuffer

fn from_iter<T: IntoIterator<Item = (C, bool)>>(iter: T) -> Self

Creates a value from an iterator.

impl<C: CellEncoding> FromIterator<C> for MaskedCellBuffer

fn from_iter<T: IntoIterator<Item = C>>(iter: T) -> Self

Creates a value from an iterator.

impl<'buf> IntoIterator for &'buf MaskedCellBuffer

type Item = (CellValue, bool)

The type of the elements being iterated over.

type IntoIter = MaskedCellBufferIterator<'buf>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Mul<&MaskedCellBuffer> for MaskedCellBuffer

type Output = MaskedCellBuffer

The resulting type after applying the * operator.

fn mul(self, rhs: &MaskedCellBuffer) -> Self::Output

Performs the * operation.

impl<R> Mul<R> for MaskedCellBuffer

where R: Into<CellValue>,

type Output = MaskedCellBuffer

The resulting type after applying the * operator.

fn mul(self, rhs: R) -> Self::Output

Performs the * operation.

impl Mul for &MaskedCellBuffer

type Output = MaskedCellBuffer

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl Mul for MaskedCellBuffer

type Output = MaskedCellBuffer

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl Neg for &MaskedCellBuffer

type Output = MaskedCellBuffer

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for MaskedCellBuffer

type Output = MaskedCellBuffer

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for MaskedCellBuffer

fn eq(&self, other: &MaskedCellBuffer) -> 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 PartialOrd for MaskedCellBuffer

fn partial_cmp(&self, other: &MaskedCellBuffer) -> 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 Serialize for MaskedCellBuffer

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<&MaskedCellBuffer> for MaskedCellBuffer

type Output = MaskedCellBuffer

The resulting type after applying the - operator.

fn sub(self, rhs: &MaskedCellBuffer) -> Self::Output

Performs the - operation.

impl<R> Sub<R> for MaskedCellBuffer

where R: Into<CellValue>,

type Output = MaskedCellBuffer

The resulting type after applying the - operator.

fn sub(self, rhs: R) -> Self::Output

Performs the - operation.

impl Sub for &MaskedCellBuffer

type Output = MaskedCellBuffer

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl Sub for MaskedCellBuffer

type Output = MaskedCellBuffer

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl StructuralPartialEq for MaskedCellBuffer