Struct MaskedArray

pub struct MaskedArray<A, S, D>
where
    A: Clone,
    S: Data<Elem = A> + Clone + RawDataClone,
    D: Dimension,
{
    pub data: ArrayBase<S, D>,
    pub mask: Array<bool, D>,
    pub fill_value: A,
}

Represents an array with a mask to identify invalid or missing values

Fields

data: ArrayBase<S, D>

The underlying data array

mask: Array<bool, D>

The mask array: true = masked (invalid), false = valid

fill_value: A

The fill value used when creating a filled array

Implementations

impl<A, S, D> MaskedArray<A, S, D>

where A: Clone + PartialEq, S: Data<Elem = A> + Clone + RawDataClone, D: Dimension,

pub fn new( data: ArrayBase<S, D>, mask: Option<Array<bool, D>>, fill_value: Option<A>, ) -> Result<Self, ArrayError>

Create a new MaskedArray from data and mask

Errors

Returns ArrayError::ShapeMismatch if the mask shape doesn’t match the data shape.

pub fn filled(&self, fill_value: Option<A>) -> Array<A, D>

where <D as Dimension>::Pattern: NdIndex<D>,

Get a view of the data with masked values replaced by fill_value

pub fn has_masked(&self) -> bool

Returns true if the array has at least one masked element

pub fn count(&self) -> usize

Returns the count of non-masked elements

pub fn get_mask(&self) -> Array<bool, D>

Get a copy of the current mask

pub fn set_mask(&mut self, mask: Array<bool, D>) -> Result<(), ArrayError>

Set a new mask for the array

Errors

Returns ArrayError::ShapeMismatch if the mask shape doesn’t match the data shape.

pub fn set_fill_value(&mut self, fill_value: A)

Set the fill value for the array

pub fn compressed(&self) -> Array<A, Ix1>

Returns a new array containing only unmasked values

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

Returns the shape of the array

pub fn ndim(&self) -> usize

Returns the number of dimensions of the array

pub fn size(&self) -> usize

Returns the number of elements in the array

pub const fn data_and_mask(&self) -> (&ArrayBase<S, D>, &Array<bool, D>)

Returns a tuple of (data, mask)

pub fn mask_op<F>(&self, op: F) -> Self

where F: Fn(&Array<bool, D>) -> Array<bool, D>,

Creates a new masked array with the given mask operation applied

pub fn harden_mask(&self) -> Self

Creates a new masked array with a hardened mask (copy)

pub fn soften_mask(&self) -> Self

Create a new masked array with a softened mask (copy)

pub fn mask_where<F>(&self, condition: F) -> Self

where F: Fn(&A) -> bool,

Create a new masked array where the result of applying the function to each element is masked

pub fn mask_or(&self, other_mask: &Array<bool, D>) -> Result<Self, ArrayError>

Create a logical OR of the mask with another mask

Errors

Returns ArrayError::ShapeMismatch if the mask shapes don’t match.

pub fn mask_and(&self, other_mask: &Array<bool, D>) -> Result<Self, ArrayError>

Create a logical AND of the mask with another mask

Errors

Returns ArrayError::ShapeMismatch if the mask shapes don’t match.

pub fn reshape<E>( &self, shape: E, ) -> Result<MaskedArray<A, OwnedRepr<A>, E>, ArrayError>

where E: Dimension, D: Dimension,

Reshape the masked array

Errors

Returns ArrayError::ValueError if the reshape operation fails.

pub fn astype<B>(&self) -> Result<MaskedArray<B, OwnedRepr<B>, D>, ArrayError>

where A: Into<B> + Clone, B: Clone + PartialEq + 'static,

Convert to a different type

Errors

Currently this method doesn’t return errors, but the signature is kept for future compatibility.

impl<A, S, D> MaskedArray<A, S, D>

where A: Clone + PartialEq + NumAssign + Zero + One + PartialOrd, S: Data<Elem = A> + Clone + RawDataClone, D: Dimension,

Implementation of statistical methods

pub fn sum(&self) -> A

Compute the sum of all unmasked elements

pub fn product(&self) -> A

Compute the product of all unmasked elements

pub fn min(&self) -> Option<A>

Find the minimum value among unmasked elements

pub fn max(&self) -> Option<A>

Find the maximum value among unmasked elements

pub fn argmin(&self) -> Option<usize>

Find the index of the minimum value among unmasked elements

pub fn argmax(&self) -> Option<usize>

Find the index of the maximum value among unmasked elements

impl<A, S, D> MaskedArray<A, S, D>

where A: Clone + PartialEq + Float + Sum<A>, S: Data<Elem = A> + Clone + RawDataClone, D: Dimension,

Implementation of statistical methods for floating point types

pub fn mean(&self) -> Option<A>

Compute the mean of all unmasked elements

Panics

Panics if the count cannot be converted to type A.

pub fn var(&self, ddof: usize) -> Option<A>

Compute the variance of all unmasked elements

Panics

Panics if the count cannot be converted to type A.

pub fn std(&self, ddof: usize) -> Option<A>

Compute the standard deviation of all unmasked elements

pub fn all_finite(&self) -> bool

Check if all unmasked elements are finite

Trait Implementations

impl<A, S1, S2, D> Add<&MaskedArray<A, S2, D>> for &MaskedArray<A, S1, D>

where A: Clone + Add<Output = A> + PartialEq, S1: Data<Elem = A> + Clone + RawDataClone, S2: Data<Elem = A> + Clone + RawDataClone, D: Dimension,

type Output = MaskedArray<A, OwnedRepr<A>, D>

The resulting type after applying the + operator.

fn add(self, rhs: &MaskedArray<A, S2, D>) -> Self::Output

Performs the + operation.

impl<A, S, D> Clone for MaskedArray<A, S, D>

where A: Clone + Clone, S: Data<Elem = A> + Clone + RawDataClone + Clone, D: Dimension + Clone,

fn clone(&self) -> MaskedArray<A, S, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, S, D> Debug for MaskedArray<A, S, D>

where A: Clone + PartialEq + Debug, S: Data<Elem = A> + Clone + RawDataClone, D: Dimension,

Implementation of Debug for MaskedArray

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

Formats the value using the given formatter.

impl<A, S, D> Display for MaskedArray<A, S, D>

where A: Clone + PartialEq + Display, S: Data<Elem = A> + Clone + RawDataClone, D: Dimension,

Implementation of Display for MaskedArray

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

Formats the value using the given formatter.

impl<A, S1, S2, D> Div<&MaskedArray<A, S2, D>> for &MaskedArray<A, S1, D>

where A: Clone + Div<Output = A> + PartialEq + Zero, S1: Data<Elem = A> + Clone + RawDataClone, S2: Data<Elem = A> + Clone + RawDataClone, D: Dimension,

type Output = MaskedArray<A, OwnedRepr<A>, D>

The resulting type after applying the / operator.

fn div(self, rhs: &MaskedArray<A, S2, D>) -> Self::Output

Performs the / operation.

impl<A, S1, S2, D> Mul<&MaskedArray<A, S2, D>> for &MaskedArray<A, S1, D>

where A: Clone + Mul<Output = A> + PartialEq, S1: Data<Elem = A> + Clone + RawDataClone, S2: Data<Elem = A> + Clone + RawDataClone, D: Dimension,

type Output = MaskedArray<A, OwnedRepr<A>, D>

The resulting type after applying the * operator.

fn mul(self, rhs: &MaskedArray<A, S2, D>) -> Self::Output

Performs the * operation.

impl<A, S1, S2, D> Sub<&MaskedArray<A, S2, D>> for &MaskedArray<A, S1, D>

where A: Clone + Sub<Output = A> + PartialEq, S1: Data<Elem = A> + Clone + RawDataClone, S2: Data<Elem = A> + Clone + RawDataClone, D: Dimension,

type Output = MaskedArray<A, OwnedRepr<A>, D>

The resulting type after applying the - operator.

fn sub(self, rhs: &MaskedArray<A, S2, D>) -> Self::Output

Performs the - operation.