@sjcrh/proteinpaint-rust 2.129.2 → 2.129.6

package/src/stats_functions.rs

@@ -1,6 +1,9 @@
+#![allow(non_snake_case)]
 use fishers_exact::fishers_exact;
 //use r_mathlib;
+use r_mathlib::chi_squared_cdf;
 use statrs::distribution::{ChiSquared, ContinuousCDF};
+use std::collections::HashSet;
 use std::panic;
 
 #[allow(dead_code)]
@@ -99,24 +102,19 @@ fn chi_square_test(
     {
         0.05 // Arbitarily put a very high number when there are only forward or reverse reads for alternate/reference
     } else {
-        let total: f64 = (alternate_forward_count
-            + alternate_reverse_count
-            + reference_forward_count
-            + reference_reverse_count) as f64;
-        let expected_alternate_forward_count: f64 = (alternate_forward_count
-            + alternate_reverse_count) as f64
+        let total: f64 =
+            (alternate_forward_count + alternate_reverse_count + reference_forward_count + reference_reverse_count)
+                as f64;
+        let expected_alternate_forward_count: f64 = (alternate_forward_count + alternate_reverse_count) as f64
             * (alternate_forward_count + reference_forward_count) as f64
             / total;
-        let expected_alternate_reverse_count: f64 = (alternate_forward_count
-            + alternate_reverse_count) as f64
+        let expected_alternate_reverse_count: f64 = (alternate_forward_count + alternate_reverse_count) as f64
             * (alternate_reverse_count + reference_reverse_count) as f64
             / total;
-        let expected_reference_forward_count: f64 = (alternate_forward_count
-            + reference_forward_count) as f64
+        let expected_reference_forward_count: f64 = (alternate_forward_count + reference_forward_count) as f64
             * (reference_forward_count + reference_reverse_count) as f64
             / total;
-        let expected_reference_reverse_count: f64 = (reference_forward_count
-            + reference_reverse_count) as f64
+        let expected_reference_reverse_count: f64 = (reference_forward_count + reference_reverse_count) as f64
             * (alternate_reverse_count + reference_reverse_count) as f64
             / total;
 
@@ -315,15 +313,12 @@ pub fn wilcoxon_rank_sum_test(
         //println!("z_original:{}", z);
         let mut nties_sum: f64 = 0.0;
         for i in 0..rank_frequencies.len() {
-            nties_sum += rank_frequencies[i] * rank_frequencies[i] * rank_frequencies[i]
-                - rank_frequencies[i];
+            nties_sum += rank_frequencies[i] * rank_frequencies[i] * rank_frequencies[i] - rank_frequencies[i];
         }
 
         let sigma = (((group1.len() * group2.len()) as f64) / 12.0
             * ((group1.len() + group2.len() + 1) as f64
-                - nties_sum
-                    / (((group1.len() + group2.len()) as f64)
-                        * ((group1.len() + group2.len() - 1) as f64))))
+                - nties_sum / (((group1.len() + group2.len()) as f64) * ((group1.len() + group2.len() - 1) as f64))))
             .sqrt();
         //println!("sigma:{}", sigma);
         let mut correction: f64 = 0.0;
@@ -412,3 +407,82 @@ pub fn calculate_frac_rank(current_rank: f64, num_repeats: f64) -> f64 {
     }
     sum / num_repeats
 }
+
+#[allow(non_camel_case_types)]
+#[allow(non_snake_case)]
+#[derive(Debug, Clone, PartialEq, PartialOrd)]
+pub struct gene_order {
+    pub gene_name: String,
+    pub fold_change: f32,
+    pub rank: Option<usize>,
+}
+
+#[allow(dead_code)]
+pub fn cerno(
+    genes_descending: &Vec<gene_order>,
+    genes_ascending: &Vec<gene_order>,
+    genes_in_pathway: HashSet<String>,
+) -> (f32, f32, f32, f32, String, f32) {
+    // Ensure sample_coding_genes is sorted in decreasing order of fold_change
+    // Filter the genes_descending vector to only include those whose gene_names are in the HashSet genes_in_pathway
+    let gene_intersections_descending: Vec<&gene_order> = genes_descending
+        .iter()
+        .filter(|genes_descending| genes_in_pathway.contains(&genes_descending.gene_name)) // Check if name is in the HashSet genes_in_pathway
+        .collect(); // Collect the results into a new vector
+
+    let N1 = gene_intersections_descending.len() as f32;
+    let N = genes_descending.len() as f32;
+    let mut gene_set_hits: String = "".to_string();
+    for gene in &gene_intersections_descending {
+        gene_set_hits += &(gene.gene_name.to_string() + &",");
+    }
+    if gene_intersections_descending.len() > 0 {
+        // Remove the last "," in string
+        gene_set_hits.pop();
+    }
+
+    let ranks_descending: Vec<usize> = gene_intersections_descending // x <- l %in% mset$gs2gv[[m]] ; ranks <- c(1:N)[x]
+        .iter()
+        .map(|x| x.rank.unwrap())
+        .collect::<Vec<usize>>();
+
+    let cerno: f32 = ranks_descending // -2 * sum( log(ranks/N) )
+        .iter()
+        .map(|x| ((*x as f32) / N).ln())
+        .collect::<Vec<f32>>()
+        .iter()
+        .sum::<f32>()
+        * (-2.0);
+
+    let cES;
+    let N2 = N - N1; // N2 = N - N1
+    let R1 = ranks_descending.iter().sum::<usize>() as f32; // R1 <- sum(ranks)
+    let U = N1 * N2 + N1 * (N1 + 1.0) / 2.0 - R1; // U  <- N1*N2+N1*(N1+1)/2-R1
+    let AUC = U / (N1 * N2); // AUC <- U/(N1*N2)
+    let p_value;
+    if AUC >= 0.5 {
+        // Upregulated geneset
+        cES = cerno / (2.0 * (N1 as f32)); // cES <- cerno/(2*N1)
+        p_value = chi_squared_cdf(cerno as f64, (2.0 * N1) as f64, false, false);
+    // pchisq(ret$cerno, 2*N1, lower.tail=FALSE)
+    } else {
+        let gene_intersections_ascending: Vec<&gene_order> = genes_ascending
+            .iter()
+            .filter(|genes_ascending| genes_in_pathway.contains(&genes_ascending.gene_name)) // Check if name is in the HashSet genes_in_pathway
+            .collect(); // Collect the results into a new vector
+        let ranks_ascending: Vec<usize> = gene_intersections_ascending // x <- l %in% mset$gs2gv[[m]] ; ranks <- c(1:N)[x]
+            .iter()
+            .map(|x| x.rank.unwrap())
+            .collect::<Vec<usize>>();
+        let cerno_ascending: f32 = ranks_ascending // -2 * sum( log(ranks/N) )
+            .iter()
+            .map(|x| ((*x as f32) / N).ln())
+            .collect::<Vec<f32>>()
+            .iter()
+            .sum::<f32>()
+            * (-2.0);
+        cES = cerno_ascending / (2.0 * (N1 as f32)); // cES <- cerno/(2*N1)
+        p_value = chi_squared_cdf(cerno_ascending as f64, (2.0 * N1) as f64, false, false);
+    }
+    (p_value as f32, AUC, cES, N1, gene_set_hits, cerno)
+}

package/src/test_cerno.rs

@@ -0,0 +1,131 @@
+// For capturing output from a test, run: cd .. && cargo test -- --nocapture
+#[allow(dead_code)]
+fn main() {}
+
+#[cfg(test)]
+mod tests {
+    use crate::stats_functions::cerno;
+    use flate2::read::GzDecoder;
+    use json::JsonValue;
+    use std::cmp::Ordering;
+    use std::collections::HashSet;
+    use std::fs::File;
+    use std::io::{BufReader, Read};
+
+    const P_VALUE_CUTOFF: f32 = 0.01; // Threshold difference between calculated and expected p-value for the test to pass
+    const AUC_CUTOFF: f32 = 0.001; // Threshold difference between calculated and expected AUC for the test to pass
+    const ES_CUTOFF: f32 = 0.01; // Threshold difference between calculated and expected ES for the test to pass
+    const CERNO_CUTOFF: f32 = 1.0; // Threshold difference between calculated and expected CERNO value for the test to pass
+    #[test]
+    fn cerno_test() {
+        // Specify the path to the json file
+        let file_path = "test/cerno_test.json.gz";
+        // Open the file
+        let file = File::open(file_path).unwrap();
+        // Create a buffered reader
+        let buf_reader = BufReader::new(file);
+
+        // Create a GzDecoder to read the Gzip data
+        let mut gz_decoder = GzDecoder::new(buf_reader);
+
+        // Create a String to hold the first line
+        let mut first_line = String::new();
+
+        // Read the decompressed data into the String
+        gz_decoder.read_to_string(&mut first_line).unwrap();
+
+        // Read the first line
+        //buf_reader.read_line(&mut first_line).unwrap();
+        let input_json = json::parse(&first_line);
+        match input_json {
+            Ok(json_string) => {
+                let sample_genes_input: &JsonValue = &json_string["input_genes"];
+                let mut sample_genes = Vec::<&str>::new();
+                for iter in 0..sample_genes_input.len() {
+                    let item = sample_genes_input[iter].as_str().unwrap();
+                    sample_genes.push(item);
+                }
+                let fold_change_input: &JsonValue = &json_string["input_fold_change"];
+                let mut fold_change_f32 = Vec::<f32>::new();
+                for iter in 0..fold_change_input.len() {
+                    let item = fold_change_input[iter].as_f32().unwrap();
+                    fold_change_f32.push(item);
+                }
+
+                let mut sample_coding_genes: Vec<crate::stats_functions::gene_order> =
+                    Vec::with_capacity(sample_genes.len());
+                for i in 0..sample_genes.len() {
+                    let item: crate::stats_functions::gene_order = crate::stats_functions::gene_order {
+                        gene_name: sample_genes[i].to_string(),
+                        fold_change: fold_change_f32[i],
+                        rank: None, // Will be calculated later
+                    };
+                    sample_coding_genes.push(item)
+                }
+
+                // Sort sample_coding_gene in descending order
+                sample_coding_genes
+                    .as_mut_slice()
+                    .sort_by(|a, b| (b.fold_change).partial_cmp(&a.fold_change).unwrap_or(Ordering::Equal));
+                let mut genes_descending = sample_coding_genes.clone();
+                // Sort sample_coding_gene in ascending order
+                sample_coding_genes
+                    .as_mut_slice()
+                    .sort_by(|a, b| (a.fold_change).partial_cmp(&b.fold_change).unwrap_or(Ordering::Equal));
+                let mut genes_ascending = sample_coding_genes.clone();
+
+                drop(sample_coding_genes); // sample_coding_genes no longer deleted, so the variable is deleted
+
+                // Assign ranks to each gene
+                for i in 0..genes_descending.len() {
+                    genes_descending[i].rank = Some(i);
+                    genes_ascending[i].rank = Some(i);
+                }
+
+                let modules_2_genes: &JsonValue = &json_string["MODULES2GENES"];
+                let expected_p_values_json: &JsonValue = &json_string["expected_p_values"]; // The expected p-value comes from the original tmod package in R
+                let expected_auc_json: &JsonValue = &json_string["expected_auc"]; // The expected auc comes from the original tmod package in R
+                let expected_es_json: &JsonValue = &json_string["expected_es"]; // The expected es comes from the original tmod package in R
+                let expected_cerno_json: &JsonValue = &json_string["expected_cerno"]; // The expected cerno comes from the original tmod package in R
+
+                let mut expected_p_values = Vec::<f32>::new();
+                let mut expected_auc = Vec::<f32>::new();
+                let mut expected_es = Vec::<f32>::new();
+                let mut expected_cerno = Vec::<f32>::new();
+
+                for j in 0..expected_p_values_json.len() {
+                    expected_p_values.push(expected_p_values_json[j].as_f32().unwrap());
+                    expected_auc.push(expected_auc_json[j].as_f32().unwrap());
+                    expected_es.push(expected_es_json[j].as_f32().unwrap());
+                    expected_cerno.push(expected_cerno_json[j].as_f32().unwrap());
+                }
+
+                let mut iter = 0;
+                for item in modules_2_genes.entries() {
+                    let (key, value) = item;
+                    let mut geneset = HashSet::<String>::new();
+                    for item2 in value.members() {
+                        geneset.insert(item2.to_string());
+                    }
+                    let (p_value, auc, es, _matches, _gene_set_hits, cerno_output) =
+                        cerno(&genes_descending, &genes_ascending, geneset.clone());
+                    println!("Geneset name:{}", key.to_string());
+                    println!("p_value:{}", p_value);
+                    println!("auc:{}", auc);
+                    println!("es:{}", es);
+                    println!("cerno:{}", cerno_output);
+                    //println!("matches:{}", _matches1);
+                    //println!("gene_set_hits:{}", _gene_set_hits1);
+
+                    assert_eq!((p_value - expected_p_values[iter]).abs() < P_VALUE_CUTOFF, true); // The expected p-value comes from the original tmod package in R
+                    assert_eq!((auc - expected_auc[iter]).abs() < AUC_CUTOFF, true); // The expected auc comes from the original tmod package in R
+                    assert_eq!((es - expected_es[iter]).abs() < ES_CUTOFF, true); // The expected es comes from the original tmod package in R
+                    assert_eq!((cerno_output - expected_cerno[iter]).abs() < CERNO_CUTOFF, true);
+                    // The expected es comes from the original tmod package in R
+                    iter += 1;
+                }
+            }
+            Err(error) => println!("Incorrect json:{}", error),
+        }
+    }
+}

package/src/wilcoxon.rs

@@ -48,6 +48,7 @@ use serde::{Deserialize, Serialize};
 use std::io;
 
 mod stats_functions; // Import Wilcoxon function
+#[cfg(test)]
 mod test_examples; // Contains examples to test the wilcoxon rank sum test
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -101,14 +102,8 @@ fn main() {
                         if vec1.len() == 0 || vec2.len() == 0 {
                             // If one of the vectors has a length of zero, wilcoxon test is not performed and a pvalue of NULL is given.
                             output_string += &serde_json::to_string(&OutputJson {
-                                group1_id: json_string[i]["group1_id"]
-                                    .as_str()
-                                    .unwrap()
-                                    .to_string(),
-                                group2_id: json_string[i]["group2_id"]
-                                    .as_str()
-                                    .unwrap()
-                                    .to_string(),
+                                group1_id: json_string[i]["group1_id"].as_str().unwrap().to_string(),
+                                group2_id: json_string[i]["group2_id"].as_str().unwrap().to_string(),
                                 group1_values: vec1,
                                 group2_values: vec2,
                                 pvalue: None,
@@ -129,14 +124,8 @@ fn main() {
                             //}
                             //println!("pvalue:{}", pvalue);
                             output_string += &serde_json::to_string(&OutputJson {
-                                group1_id: json_string[i]["group1_id"]
-                                    .as_str()
-                                    .unwrap()
-                                    .to_string(),
-                                group2_id: json_string[i]["group2_id"]
-                                    .as_str()
-                                    .unwrap()
-                                    .to_string(),
+                                group1_id: json_string[i]["group1_id"].as_str().unwrap().to_string(),
+                                group2_id: json_string[i]["group2_id"].as_str().unwrap().to_string(),
                                 group1_values: vec1,
                                 group2_values: vec2,
                                 pvalue: Some(pvalue),