@sjcrh/proteinpaint-rust 2.129.1-80343740e.0 → 2.129.6-2b2fdc7ee.0

package/Cargo.toml

@@ -13,7 +13,7 @@ kodama = "0.3"
 rayon = "1.7.0"
 bgzip = "0.3.1"
 petgraph = "0.6.3"
-rusqlite="0.35"
+rusqlite="0.36.0"
 ndarray = "0.16.1"
 hdf5 = { package = "hdf5-metno", version = "0.9.0" }
 nalgebra = {version = "0.32.2", features = ["serde-serialize"]}
@@ -35,7 +35,7 @@ flate2 = "1"
 futures = "0.3" 
 num_cpus = "1.16.0"
 memchr = "2"
-r2d2_sqlite = "0.28.0"
+r2d2_sqlite = "0.29.0"
 r2d2 = "0.8.10"
 
 [profile.release]

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "2.129.1-80343740e.0",
+	"version": "2.129.6-2b2fdc7ee.0",
 	"name": "@sjcrh/proteinpaint-rust",
 	"type": "module",
 	"description": "Rust-based utilities for proteinpaint",

package/src/cerno.rs

@@ -1,7 +1,6 @@
 // Syntax: cd .. && cargo build --release && time cat ~/sjpp/test.txt | target/release/cerno
 #![allow(non_snake_case)]
 use json::JsonValue;
-use r_mathlib::chi_squared_cdf;
 use r2d2;
 use r2d2_sqlite::SqliteConnectionManager;
 use rusqlite::{Connection, Result};
@@ -13,6 +12,10 @@ use std::io;
 use std::sync::{Arc, Mutex}; // Multithreading library
 use std::thread;
 
+mod stats_functions;
+#[cfg(test)]
+mod test_cerno; // Contains test examples to test cerno
+
 #[allow(non_camel_case_types)]
 #[allow(non_snake_case)]
 #[derive(Debug, Clone)]
@@ -20,15 +23,6 @@ struct GO_pathway {
     GO_id: String,
 }
 
-#[allow(non_camel_case_types)]
-#[allow(non_snake_case)]
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
-struct gene_order {
-    gene_name: String,
-    fold_change: f32,
-    rank: Option<usize>,
-}
-
 #[allow(non_camel_case_types)]
 #[allow(non_snake_case)]
 #[derive(Debug, Serialize, Deserialize)]
@@ -102,9 +96,9 @@ fn main() -> Result<()> {
                         panic!("Length of genes array and fold change array are not equal");
                     }
 
-                    let mut genes_vector: Vec<gene_order> = Vec::with_capacity(sample_genes.len());
+                    let mut genes_vector: Vec<stats_functions::gene_order> = Vec::with_capacity(sample_genes.len());
                     for i in 0..sample_genes.len() {
-                        let item: gene_order = gene_order {
+                        let item: stats_functions::gene_order = stats_functions::gene_order {
                             gene_name: sample_genes[i].to_string(),
                             fold_change: fold_change_f32[i],
                             rank: None, // Will be calculated later
@@ -125,7 +119,7 @@ fn main() -> Result<()> {
 
                     let genedbconn = Connection::open(genedb)?;
                     let genedb_result = genedbconn.prepare(&("select * from codingGenes"));
-                    let mut sample_coding_genes: Vec<gene_order> = Vec::with_capacity(24000);
+                    let mut sample_coding_genes: Vec<stats_functions::gene_order> = Vec::with_capacity(24000);
                     match genedb_result {
                         Ok(mut x) => {
                             let mut genes = x.query([])?;
@@ -152,10 +146,22 @@ fn main() -> Result<()> {
                     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();
+                    //println!("genes_descending:{:?}", genes_descending);
+
+                    // Sort sample_coding_gene in descending 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();
+                    //println!("genes_ascending:{:?}", genes_ascending);
+
+                    drop(sample_coding_genes); // sample_coding_genes no longer deleted, so the variable is deleted
 
                     // Assign ranks to each gene
-                    for i in 0..sample_coding_genes.len() {
-                        sample_coding_genes[i].rank = Some(i)
+                    for i in 0..genes_descending.len() {
+                        genes_descending[i].rank = Some(i);
+                        genes_ascending[i].rank = Some(i)
                     }
 
                     //println!("sample_genes:{:?}", sample_genes);
@@ -206,7 +212,8 @@ fn main() -> Result<()> {
                                         }
                                     }
                                     let gene_set_size = names.len();
-                                    let (p_value, auc, es, matches, gene_set_hits) = cerno(&sample_coding_genes, names);
+                                    let (p_value, auc, es, matches, gene_set_hits, _cerno_output) =
+                                        stats_functions::cerno(&genes_descending, &genes_ascending, names);
 
                                     if matches >= 1.0
                                         && p_value.is_nan() == false
@@ -232,14 +239,16 @@ fn main() -> Result<()> {
                                 let pool = r2d2::Pool::new(manager).unwrap(); // This enables sqlite query from multiple threads simultaneously
                                 let genesets = Arc::new(genesets);
                                 let pool_arc = Arc::new(pool);
-                                let sample_coding_genes = Arc::new(sample_coding_genes);
+                                let genes_descending = Arc::new(genes_descending);
+                                let genes_ascending = Arc::new(genes_ascending);
                                 let pathway_p_values_temp =
                                     Arc::new(Mutex::new(Vec::<pathway_p_value>::with_capacity(genesets.len())));
                                 let mut handles = vec![]; // Vector to store handle which is used to prevent one thread going ahead of another
                                 for thread_num in 0..max_threads {
                                     let genesets = Arc::clone(&genesets);
                                     let pool_arc = Arc::clone(&pool_arc);
-                                    let sample_coding_genes = Arc::clone(&sample_coding_genes);
+                                    let genes_descending = Arc::clone(&genes_descending);
+                                    let genes_ascending = Arc::clone(&genes_ascending);
                                     let pathway_p_values_temp = Arc::clone(&pathway_p_values_temp);
                                     let handle = thread::spawn(move || {
                                         let mut pathway_p_values_thread: Vec<pathway_p_value> =
@@ -275,8 +284,8 @@ fn main() -> Result<()> {
                                                     }
                                                 }
                                                 let gene_set_size = names.len();
-                                                let (p_value, auc, es, matches, gene_set_hits) =
-                                                    cerno(&sample_coding_genes, names);
+                                                let (p_value, auc, es, matches, gene_set_hits, _cerno_output) =
+                                                    stats_functions::cerno(&genes_descending, &genes_ascending, names);
 
                                                 if matches >= 1.0
                                                     && p_value.is_nan() == false
@@ -326,46 +335,6 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-fn cerno(sample_coding_genes: &Vec<gene_order>, genes_in_pathway: HashSet<String>) -> (f32, f32, f32, f32, String) {
-    // Filter the sample_coding_genes vector to only include those whose gene_names are in the HashSet genes_in_pathway
-    let gene_intersections: Vec<&gene_order> = sample_coding_genes
-        .iter()
-        .filter(|sample_coding_genes| genes_in_pathway.contains(&sample_coding_genes.gene_name)) // Check if name is in the HashSet genes_in_pathway
-        .collect(); // Collect the results into a new vector
-
-    let N1 = gene_intersections.len() as f32;
-    let N = sample_coding_genes.len() as f32;
-    let mut gene_set_hits: String = "".to_string();
-    for gene in &gene_intersections {
-        gene_set_hits += &(gene.gene_name.to_string() + &",");
-    }
-    if gene_intersections.len() > 0 {
-        // Remove the last "," in string
-        gene_set_hits.pop();
-    }
-
-    let ranks: Vec<usize> = gene_intersections // x <- l %in% mset$gs2gv[[m]] ; ranks <- c(1:N)[x]
-        .iter()
-        .map(|x| x.rank.unwrap())
-        .collect::<Vec<usize>>();
-
-    let cerno: f32 = ranks // -2 * sum( log(ranks/N) )
-        .iter()
-        .map(|x| ((*x as f32) / N).ln())
-        .collect::<Vec<f32>>()
-        .iter()
-        .sum::<f32>()
-        * (-2.0);
-
-    let cES: f32 = cerno / (2.0 * (N1 as f32)); // cES <- cerno/(2*N1)
-    let N2 = N - N1; // N2 = N - N1
-    let R1 = ranks.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 = chi_squared_cdf(cerno as f64, (2.0 * N1) as f64, false, false); // pchisq(ret$cerno, 2*N1, lower.tail=FALSE)
-    (p_value as f32, AUC, cES, N1, gene_set_hits)
-}
-
 fn adjust_p_values(mut original_p_values: Vec<pathway_p_value>) -> String {
     // Sorting p-values in ascending order
     original_p_values.as_mut_slice().sort_by(|a, b| {