Method top_segment_proportions

src/memory/statistics/mod.rs:282–336

(
        &self,
        direction: &Direction,
        ns: &[usize],
    )

impl ComputeTopSegmentProportions for IMArrayElement {
    fn top_segment_proportions(
        &self,
        direction: &Direction,
        ns: &[usize],
    ) -> anyhow::Result<ndarray::Array2<f64>> {
        let shape = self.get_shape()?;
        let (n_items, n_features) = match direction {
            Direction::ROW => (shape[0], shape[1]),
            Direction::COLUMN => (shape[1], shape[0]),
        };

        for &n in ns {
            if n > n_features {
                return Err(anyhow::anyhow!(
                    "Requested top {} features but only {} available",
                    n,
                    n_features
                ));
            }
        }

        let totals: Vec<f64> = self.sum_whole(direction)?;

        let mut proportions = ndarray::Array2::<f64>::zeros((n_items, ns.len()));

        let mut unique_ns: Vec<usize> = ns.to_vec();
        unique_ns.sort_unstable();
        unique_ns.dedup();

        let mut n_to_indices: std::collections::HashMap<usize, Vec<usize>> =
            std::collections::HashMap::new();
        for (idx, &n) in ns.iter().enumerate() {
            n_to_indices.entry(n).or_default().push(idx);
        }

        for &n in &unique_ns {
            let top_values: Vec<f64> = self.n_top_whole(direction, n)?;

            for item_idx in 0..n_items {
                let total = totals[item_idx];
                if total > 0.0 {
                    let start_idx = item_idx * n;
                    let end_idx = start_idx + n;
                    let sum_top_n: f64 = top_values[start_idx..end_idx].iter().sum();
                    let proportion = sum_top_n / total;

                    for &ns_idx in &n_to_indices[&n] {
                        proportions[[item_idx, ns_idx]] = proportion;
                    }
                }
            }
        }

        Ok(proportions)
    }
}

/*