Struct DataArray 

pub struct DataArray<T: Scalar> { /* private fields */ }

A contiguous array of tuples, where each tuple has num_components values.

This is the fundamental data container, analogous to VTK’s vtkDataArray. Uses Arc<Vec<T>> for zero-copy clone with copy-on-write semantics.

Examples

use crate::data::DataArray;

// Create a 3-component array (e.g., for normals or positions)
let mut normals = DataArray::<f64>::new("Normals", 3);
normals.push_tuple(&[0.0, 0.0, 1.0]);
normals.push_tuple(&[0.0, 1.0, 0.0]);
assert_eq!(normals.num_tuples(), 2);

// Create from a Vec
let scalars = DataArray::<f64>::from_vec("Temperature", vec![10.0, 20.0, 30.0], 1);
assert_eq!(scalars.num_tuples(), 3);

Implementations

impl<T: Scalar> DataArray<T>

pub fn new(name: impl Into<String>, num_components: usize) -> Self

pub fn from_vec( name: impl Into<String>, data: Vec<T>, num_components: usize, ) -> Self

pub fn from_slice( name: impl Into<String>, data: &[T], num_components: usize, ) -> Self

Create from a borrowed slice (copies data).

pub fn name(&self) -> &str

pub fn set_name(&mut self, name: impl Into<String>)

pub fn scalar_type(&self) -> ScalarType

pub fn num_components(&self) -> usize

pub fn num_tuples(&self) -> usize

pub fn tuple(&self, idx: usize) -> &[T]

pub fn tuple_mut(&mut self, idx: usize) -> &mut [T]

pub fn push_tuple(&mut self, values: &[T])

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

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

pub fn into_vec(self) -> Vec<T>

pub fn is_empty(&self) -> bool

pub fn from_fn( name: impl Into<String>, count: usize, f: impl Fn(usize) -> T, ) -> Self

Create a 1-component DataArray by evaluating a function for each index.

pub fn from_fn_components( name: impl Into<String>, count: usize, num_components: usize, f: impl Fn(usize) -> Vec<T>, ) -> Self

Create a multi-component DataArray from a function returning a slice.

pub fn filled( name: impl Into<String>, value: T, count: usize, num_components: usize, ) -> Self

Create a DataArray filled with a constant value.

pub fn len(&self) -> usize

Number of total scalar values (tuples * components).

pub fn map_in_place(&mut self, f: impl Fn(T) -> T)

Apply a function to each scalar value in-place.

pub fn map(&self, name: impl Into<String>, f: impl Fn(T) -> T) -> Self

Create a new DataArray by mapping each scalar value.

pub fn map_tuples( &self, name: impl Into<String>, f: impl Fn(&[T]) -> T, ) -> DataArray<T>

Create a new 1-component DataArray from a per-tuple function.

pub fn clear(&mut self)

pub fn is_shared(&self) -> bool

Returns true if this array shares storage with another clone.

pub fn make_unique(&mut self)

Ensure exclusive ownership. Call before tight mutation loops to avoid per-call Arc::make_mut atomic checks.

pub fn iter_tuples(&self) -> DataArrayTupleIter<'_, T>

Iterate over tuples as slices.

impl DataArray<f64>

pub fn scale(&mut self, factor: f64)

Scale all values by a factor.

pub fn normalize(&mut self) -> (f64, f64)

Normalize all values to [0, 1] range. Returns the original (min, max) range.

pub fn min_value(&self) -> f64

Compute min value (first component only for multi-component).

pub fn max_value(&self) -> f64

Compute max value (first component only for multi-component).

pub fn magnitude(&self, name: impl Into<String>) -> DataArray<f64>

Compute magnitude for each tuple (Euclidean norm of components).

impl DataArray<f64>

pub fn extract_component( &self, component: usize, name: impl Into<String>, ) -> DataArray<f64>

Extract a single component as a new 1-component array.

pub fn concat(&self, other: &DataArray<f64>) -> DataArray<f64>

Concatenate two arrays with the same number of components.

pub fn extend(&mut self, other: &DataArray<f64>)

Append another array’s tuples to this array.

pub fn compose( name: impl Into<String>, components: &[&DataArray<f64>], ) -> DataArray<f64>

Create a new array by combining components from multiple 1-component arrays.

impl DataArray<f32>

pub fn scale(&mut self, factor: f32)

Scale all values by a factor.

Trait Implementations

impl<T: Scalar> Clone for DataArray<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Scalar> Debug for DataArray<T>

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

Formats the value using the given formatter.

impl From<DataArray<f32>> for AnyDataArray

fn from(a: DataArray<f32>) -> Self

Converts to this type from the input type.

impl From<DataArray<f64>> for AnyDataArray

fn from(a: DataArray<f64>) -> Self

Converts to this type from the input type.

impl From<DataArray<i16>> for AnyDataArray

fn from(a: DataArray<i16>) -> Self

Converts to this type from the input type.

impl From<DataArray<i32>> for AnyDataArray

fn from(a: DataArray<i32>) -> Self

Converts to this type from the input type.

impl From<DataArray<i64>> for AnyDataArray

fn from(a: DataArray<i64>) -> Self

Converts to this type from the input type.

impl From<DataArray<i8>> for AnyDataArray

fn from(a: DataArray<i8>) -> Self

Converts to this type from the input type.

impl From<DataArray<u16>> for AnyDataArray

fn from(a: DataArray<u16>) -> Self

Converts to this type from the input type.

impl From<DataArray<u32>> for AnyDataArray

fn from(a: DataArray<u32>) -> Self

Converts to this type from the input type.

impl From<DataArray<u64>> for AnyDataArray

fn from(a: DataArray<u64>) -> Self

Converts to this type from the input type.

impl From<DataArray<u8>> for AnyDataArray

fn from(a: DataArray<u8>) -> Self

Converts to this type from the input type.

impl<T: Scalar> Index<usize> for DataArray<T>

Index by tuple index, returns the tuple slice.

type Output = [T]

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Scalar> PartialEq for DataArray<T>

fn eq(&self, other: &Self) -> 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.