Version bump

- added pathway network struct in order to simplify computations with it

Author: Ian

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "single-utilities"
-version = "0.8.6"
+version = "0.8.7"
 edition = "2024"
 description = "This crate provdes types, traits and utility functions to the single-rust ecosystem that can be universally used. You can also use it within your own ecosystem 👀"
 homepage = "https://singlerust.com"
@@ -15,3 +15,4 @@ simd = ["dep:simba"]
 [dependencies]
 num-traits = "0.2.19"
 simba = { version = "0.9.1", optional = true }
+anyhow = "1.0.100"

Cargo.toml

@@ -60,3 +60,5 @@
 pub mod traits;
 
 pub mod types;
+
+pub(crate) mod utils;

src/lib.rs

@@ -1,7 +1,9 @@
+use crate::utils::validate_net;
+use std::collections::HashMap;
 use std::hash::Hash;
 
 /// Represents the direction of operations in matrix or array computations.
-/// 
+///
 /// This enum is used to specify whether operations should be performed
 /// along rows or columns of a data structure.
 pub enum Direction {
@@ -22,7 +24,7 @@ impl Clone for Direction {
 
 impl Direction {
     /// Checks if the direction is row-wise.
-    /// 
+    ///
     /// # Returns
     /// `true` if the direction is `ROW`, `false` if it's `COLUMN`
     pub fn is_row(&self) -> bool {
@@ -34,7 +36,7 @@ impl Direction {
 }
 
 /// A trait for types that can serve as batch identifiers.
-/// 
+///
 /// This trait is used to identify and group data in batch processing operations.
 /// Types implementing this trait must be cloneable, comparable for equality,
 /// and hashable for efficient lookup operations.
@@ -48,7 +50,7 @@ impl BatchIdentifier for u32 {}
 impl BatchIdentifier for usize {}
 
 /// Enumeration of distance metrics for mathematical computations.
-/// 
+///
 /// This enum defines common distance metrics used in machine learning,
 /// clustering, and similarity calculations. Each variant represents
 /// a different approach to measuring the distance between points or vectors.
@@ -61,3 +63,120 @@ pub enum DistanceMetric {
     /// Cosine distance - measures the cosine of the angle between vectors
     Cosine,
 }
+
+pub struct PathwayNetwork {
+    names: Vec<String>,  // name of pathways
+    starts: Vec<usize>,  // start of pathway
+    offsets: Vec<usize>, // length of pathway
+    cnct: Vec<usize>,    // gene index of pathway
+    weights: Vec<f32>,   // weight of each gene in the pathway
+}
+
+impl PathwayNetwork {
+    pub fn new(
+        names: Vec<String>,
+        starts: Vec<usize>,
+        offsets: Vec<usize>,
+        cnct: Vec<usize>,
+        weights: Vec<f32>,
+    ) -> Self {
+        Self {
+            names,
+            starts,
+            offsets,
+            cnct,
+            weights,
+        }
+    }
+
+    pub fn new_wo_weights(
+        names: Vec<String>,
+        starts: Vec<usize>,
+        offsets: Vec<usize>,
+        cnct: Vec<usize>,
+    ) -> Self {
+        let weights = vec![1f32; cnct.len()];
+        Self {
+            names,
+            starts,
+            offsets,
+            cnct,
+            weights,
+        }
+    }
+
+    pub fn new_from_vec(
+        sources: Vec<String>,
+        targets: Vec<String>,
+        weights: Option<Vec<f32>>,
+        features: Vec<String>,
+        tmin: u32,
+    ) -> Self {
+        let res = validate_net(sources, targets, weights, false).unwrap();
+        let tmin = tmin as usize;
+        let filtered: HashMap<String, Vec<(String, f32)>> = res
+            .into_iter()
+            .filter_map(|(k, v)| if v.len() >= tmin { Some((k, v)) } else { None })
+            .collect();
+
+        let name_to_id: HashMap<String, usize> = features
+            .iter()
+            .enumerate()
+            .map(|(idx, name)| (name.clone(), idx))
+            .collect();
+
+        let total_lengths = filtered.values().fold(0usize, |v, a| v + a.len());
+        let num_pathways = filtered.len();
+
+        let mut names: Vec<String> = Vec::with_capacity(num_pathways);
+        let mut starts: Vec<usize> = Vec::with_capacity(num_pathways);
+        let mut offsets: Vec<usize> = Vec::with_capacity(num_pathways);
+        let mut cnct: Vec<usize> = Vec::with_capacity(total_lengths);
+        let mut weights_vec: Vec<f32> = Vec::with_capacity(total_lengths);
+
+        let mut i = 0usize;
+
+        for (k, v) in filtered.into_iter() {
+            let len = v.len();
+
+            for (g_name, g_weight) in v {
+                let g_idx = name_to_id.get(&g_name).unwrap();
+                cnct.push(*g_idx);
+                weights_vec.push(g_weight);
+            }
+
+            names.push(k);
+            starts.push(i);
+            offsets.push(len);
+            i += len;
+        }
+
+        Self {
+            names,
+            starts,
+            offsets,
+            cnct,
+            weights: weights_vec,
+        }
+    }
+
+    pub fn get_pathway_name(&self, idx: usize) -> &str {
+        self.names[idx].as_str()
+    }
+
+    pub fn get_pathway_features(&self, idx: usize) -> &[usize] {
+        let srt = self.starts[idx];
+        let off = srt + self.offsets[idx];
+        &self.cnct[srt..off]
+    }
+
+    pub fn get_pathway_features_and_weights(&self, idx: usize) -> (&[usize], &[f32]) {
+        let srt = self.starts[idx];
+        let off = srt + self.offsets[idx];
+        (&self.cnct[srt..off], &self.weights[srt..off])
+    }
+
+    pub fn get_num_pathways(&self) -> usize {
+        self.names.len()
+    }
+}

src/types/mod.rs

@@ -0,0 +1,58 @@
+use anyhow::anyhow;
+use std::collections::HashMap;
+
+pub fn validate_net(
+    source: Vec<String>,
+    target: Vec<String>,
+    weights: Option<Vec<f32>>,
+    verbose: bool,
+) -> anyhow::Result<HashMap<String, Vec<(String, f32)>>> {
+    let len_source = source.len();
+    let len_target = target.len();
+    if (len_source != len_target) {
+        return Err(anyhow!(
+            "Source and target must have the same length in order to be used for network construction!"
+        ));
+    }
+
+    let mut map: HashMap<String, Vec<(String, f32)>> = HashMap::new();
+    let mut current_src: String = "".to_string();
+    let mut current_target_weight: HashMap<String, f32> = HashMap::new();
+    for (i, src) in source.iter().enumerate() {
+        if current_src.is_empty() {
+            // never set a value in there
+            current_src = src.clone();
+        }
+
+        if current_src != *src {
+            // incase this is a different node now
+            if !current_target_weight.is_empty() {
+                let data: Vec<(String, f32)> = current_target_weight
+                    .iter()
+                    .map(|(key, value)| (key.clone(), *value))
+                    .collect();
+                map.insert(current_src, data);
+                // cleanup
+                current_target_weight.clear();
+                current_src = src.clone();
+            }
+        }
+
+        let src_target = target[i].clone();
+        let src_target_weight = match &weights {
+            Some(we) => we[i],
+            None => 1f32,
+        };
+        current_target_weight.insert(src_target, src_target_weight);
+    }
+
+    if !current_target_weight.is_empty() {
+        let data: Vec<(String, f32)> = current_target_weight
+            .iter()
+            .map(|(key, value)| (key.clone(), *value))
+            .collect();
+        map.insert(current_src, data);
+    }
+
+    Ok(map)
+}