crispr_screen 0.2.5

A fast and configurable differential expression analysis tool for CRISPR screens
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use crate::aggregation::AggregationResult;
use anyhow::Result;
use ndarray::Array1;
use std::{
    fs::File,
    io::{BufWriter, Write},
};

pub struct GeneFrame<'a> {
    gene: &'a [String],
    gene_fc: &'a Array1<f64>,
    gene_log2_fc: &'a Array1<f64>,
    score_low: &'a Array1<f64>,
    pvalue_low: &'a Array1<f64>,
    fdr_low: &'a Array1<f64>,
    score_high: &'a Array1<f64>,
    pvalue_high: &'a Array1<f64>,
    fdr_high: &'a Array1<f64>,
    pvalue: &'a Array1<f64>,
    fdr: &'a Array1<f64>,
    phenotype_score: &'a Array1<f64>,
    size: usize,
}

impl<'a> GeneFrame<'a> {
    pub fn new(aggregation_results: &'a AggregationResult) -> Self {
        Self {
            gene: aggregation_results.genes(),
            gene_fc: aggregation_results.gene_fc(),
            gene_log2_fc: aggregation_results.gene_log2_fc(),
            score_low: aggregation_results.score_low(),
            pvalue_low: aggregation_results.pvalues_low(),
            fdr_low: aggregation_results.fdr_low(),
            score_high: aggregation_results.score_high(),
            pvalue_high: aggregation_results.pvalues_high(),
            fdr_high: aggregation_results.fdr_high(),
            pvalue: aggregation_results.pvalue(),
            fdr: aggregation_results.fdr(),
            size: aggregation_results.genes().len(),
            phenotype_score: aggregation_results.phenotype_score(),
        }
    }

    pub fn write(&self, prefix: &str) -> Result<()> {
        let mut writer = File::create(format!("{prefix}.gene_results.tsv")).map(BufWriter::new)?;

        writeln!(
            writer,
            "gene\tfold_change\tlog_fold_change\tscore_low\tpvalue_low\tfdr_low\tscore_high\tpvalue_high\tfdr_high\tpvalue\tfdr\tphenotype_score"
        )?;

        for idx in 0..self.size {
            writeln!(
                writer,
                "{}\t{:e}\t{:e}\t{:e}\t{:e}\t{:e}\t{:e}\t{:e}\t{:e}\t{:e}\t{:e}\t{:e}",
                self.gene[idx],
                self.gene_fc[idx],
                self.gene_log2_fc[idx],
                self.score_low[idx],
                self.pvalue_low[idx],
                self.fdr_low[idx],
                self.score_high[idx],
                self.pvalue_high[idx],
                self.fdr_high[idx],
                self.pvalue[idx],
                self.fdr[idx],
                self.phenotype_score[idx],
            )?;
        }

        Ok(())
    }
}

#[cfg(test)]
mod testing {
    use crate::aggregation::AggregationResult;
    use ndarray::array;

    #[test]
    fn test_gene_frame() {
        let gene = vec!["gene1".to_string(), "gene2".to_string()];
        let gene_fc = array![1.0, 2.0];
        let score_low = array![0.0, 1.0];
        let pvalue_low = array![0.0, 1.0];
        let fdr_low = array![0.0, 1.0];
        let score_high = array![0.0, 1.0];
        let pvalue_high = array![0.0, 1.0];
        let fdr_high = array![0.0, 1.0];
        let threshold_low = 0.0;
        let threshold_high = 1.0;

        let aggregation_results = AggregationResult::new(
            gene,
            gene_fc,
            pvalue_low,
            pvalue_high,
            fdr_low,
            fdr_high,
            score_low,
            score_high,
            Some(threshold_low),
            Some(threshold_high),
        );
        let gene_frame = super::GeneFrame::new(&aggregation_results);
        assert_eq!(gene_frame.size, 2);
        gene_frame.write("test").unwrap();
    }
}