Struct ChunkedArray 

pub struct ChunkedArray<A, D>
where
    A: Clone,
    D: Dimension,
{
    pub data: Array<A, D>,
    pub strategy: ChunkingStrategy,
    /* private fields */
}

A chunked array that provides memory-efficient processing for large datasets

Fields

data: Array<A, D>

The underlying array data

strategy: ChunkingStrategy

The chunking strategy

Implementations

impl<A, D> ChunkedArray<A, D>

where A: Clone, D: Dimension,

pub fn new<S: Data<Elem = A>>( data: ArrayBase<S, D>, strategy: ChunkingStrategy, ) -> Self

Create a new chunked array with the given data and chunking strategy

pub fn with_memory_optimization<S: Data<Elem = A>>( data: ArrayBase<S, D>, strategy: AdvancedChunkingStrategy, ) -> Self

Create a chunked array with advanced memory optimization

pub fn optimizer(&self) -> Option<&MemoryPatternOptimizer>

Get access to the memory pattern optimizer (if available)

pub fn optimizer_mut(&mut self) -> Option<&mut MemoryPatternOptimizer>

Get mutable access to the memory pattern optimizer (if available)

pub fn record_processing_time(&mut self, duration: Duration)

Record processing time for adaptive optimization

pub fn update_access_pattern_stats(&mut self, stats: &AccessPatternStats)

Update access pattern statistics

pub fn map<F, B>(&self, f: F) -> Array<B, Ix1>

where F: Fn(&Array<A, D>) -> B + Sync, B: Clone,

Apply a function to each chunk of the array and collect the results

Returns a 1D array where each element is the result of applying the function to a chunk

pub fn par_map<F, B>(&self, f: F) -> Array<B, Ix1>

where F: Fn(&Array<A, D>) -> B + Sync + Send, B: Clone + Send + Sync, A: Send + Sync,

Apply a function to each chunk of the array in parallel and collect the results

Returns a 1D array where each element is the result of applying the function to a chunk

pub fn map_withmonitoring<F, B>(&mut self, f: F) -> Array<B, Ix1>

where F: Fn(&Array<A, D>) -> B + Sync, B: Clone,

Apply a function to each chunk with performance monitoring and adaptive optimization

pub fn map_numa_aware<F, B>(&self, f: F) -> Array<B, Ix1>

where F: Fn(&Array<A, D>) -> B + Sync + Send, B: Clone + Send + Sync, A: Send + Sync,

Apply a function to each chunk with NUMA-aware processing

pub fn map_cache_optimized<F, B>(&self, f: F) -> Array<B, Ix1>

where F: Fn(&Array<A, D>) -> B + Sync, B: Clone,

Apply a function to each chunk with cache-optimized processing

pub fn mapbandwidth_aware<F, B>(&self, f: F) -> Array<B, Ix1>

where F: Fn(&Array<A, D>) -> B + Sync, B: Clone,

Apply a function to each chunk with bandwidth-aware processing

pub fn map_power_aware<F, B>(&self, f: F) -> Array<B, Ix1>

where F: Fn(&Array<A, D>) -> B + Sync, B: Clone,

Apply a function to each chunk with power-aware processing (for mobile/embedded)

pub fn measure_memorybandwidth(&mut self) -> Option<usize>

Measure and update memory bandwidth for the optimizer

pub fn map_optimized<F, B>(&mut self, f: F) -> Array<B, Ix1>

where F: Fn(&Array<A, D>) -> B + Sync + Send, B: Clone + Send + Sync, A: Send + Sync,

Apply a function using the best available optimization strategy

pub fn update_access_pattern_statistics(&mut self, processingtimes: &[Duration])

Update access pattern statistics based on processing performance

pub fn num_chunks(&self) -> usize

Get the number of chunks

pub fn chunk_size(&self) -> usize

Get the chunk size in elements

pub fn get_chunks(&self) -> Vec<Array<A, D>>

where D: Clone,

Get chunks of the array as a vector of owned array chunks

Trait Implementations

impl<A, D> Debug for ChunkedArray<A, D>

where A: Clone + Debug, D: Dimension + Debug,

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

Formats the value using the given formatter.