Struct ExprMatrix 

pub struct ExprMatrix { /* private fields */ }

An expression matrix with named rows (features/genes) and columns (samples).

Element (row i, col j) is stored at data[i * ncol + j]. Missing values are represented as f64::NAN (the analog of R’s NA).

Implementations

impl ExprMatrix

pub fn new( row_names: Vec<String>, col_names: Vec<String>, data: Vec<f64>, ) -> Self

Build a matrix from row names, column names, and row-major data.

Panics if data.len() != row_names.len() * col_names.len().

Examples found in repository

examples/quickstart.rs (line 39)

fn main() {
    // 6 genes (rows) x 3 samples (cols), log2-scale expression, stored row-major.
    // Five are MCP-counter markers; GAPDH is a non-marker housekeeping gene and
    // is ignored, exactly as in R (markers are matched by name against the
    // bundled signature).
    let genes = vec![
        "CD3D".to_string(),  // T cells
        "CD28".to_string(),  // T cells
        "CD8B".to_string(),  // CD8 T cells
        "CD19".to_string(),  // B lineage
        "CD79A".to_string(), // B lineage
        "GAPDH".to_string(), // not a marker -> ignored
    ];
    let samples = vec![
        "tumor_A".to_string(),
        "tumor_B".to_string(),
        "normal".to_string(),
    ];
    #[rustfmt::skip]
    let data = vec![
        //  tumor_A  tumor_B  normal
            8.1,     7.4,     2.0, // CD3D
            7.6,     7.1,     1.8, // CD28
            6.9,     6.2,     1.5, // CD8B
            4.2,     8.3,     2.1, // CD19
            4.0,     8.0,     1.9, // CD79A
           11.0,    11.1,    11.0, // GAPDH (flat housekeeping)
    ];

    let expr = ExprMatrix::new(genes, samples, data);
    let result = mcp_counter(&expr, FeaturesType::HugoSymbols);

    // Each score is the mean of a population's present markers. Populations with
    // no present markers are dropped (as in R); the rest appear in MCP-counter's
    // signature order: T cells, CD8 T cells, B lineage.
    print!("{:<14}", "population");
    for s in &result.samples {
        print!("{s:>10}");
    }
    println!();
    for (p, pop) in result.populations.iter().enumerate() {
        print!("{pop:<14}");
        for s in 0..result.samples.len() {
            print!("{:>10.3}", result.score(p, s));
        }
        println!();
    }
}

pub fn nrow(&self) -> usize

Number of rows (features).

Examples found in repository

examples/parity_realdata.rs (line 84)

fn main() {
    let dir = PathBuf::from(DATA_DIR);

    // --- MCP-counter on human racle (HUGO symbols) ---
    let mcp_expr = read_tsv_matrix(&read_dump(&dir.join("mcp_real_input.tsv")));
    let mcp_exp = read_dump(&dir.join("mcp_real_expected.tsv"));
    let mcp_genes = mcp_expr.nrow();
    let mcp_res = mcp_counter(&mcp_expr, FeaturesType::HugoSymbols);
    let mcp_worst = worst_rel_err(&mcp_res, &mcp_exp);

    // --- mMCP-counter on mouse petitprez (Gene.Symbol, GCRm39) ---
    let mmcp_expr = read_tsv_matrix(&read_dump(&dir.join("mmcp_real_input.tsv")));
    let mmcp_exp = read_dump(&dir.join("mmcp_real_expected.tsv"));
    let mmcp_genes = mmcp_expr.nrow();
    let mmcp_res = mmcp_counter(
        &mmcp_expr,
        MurineFeaturesType::GeneSymbol,
        GenomeVersion::GCRm39,
    );
    let mmcp_worst = worst_rel_err(&mmcp_res, &mmcp_exp);

    // --- report ---
    println!("Real-data parity vs R reference estimators (R 4.6.0)\n");
    println!(
        "  {:<13} {:<18} {:>7} {:>4} pops {:>3} samples   worst rel err {:>9}",
        "MCP-counter",
        "dataset_racle",
        mcp_genes,
        mcp_res.populations.len(),
        mcp_res.samples.len(),
        format!("{mcp_worst:e}"),
    );
    println!(
        "  {:<13} {:<18} {:>7} {:>4} pops {:>3} samples   worst rel err {:>9}",
        "mMCP-counter",
        "dataset_petitprez",
        mmcp_genes,
        mmcp_res.populations.len(),
        mmcp_res.samples.len(),
        format!("{mmcp_worst:e}"),
    );

    // --- aggregate metrics (raw matrices are never committed) ---
    let json = format!(
        r#"{{
  "description": "Real-data parity: mcpcounter-rust vs R reference estimators (R 4.6.0)",
  "regenerate": "Rscript benchmarks/parity_realdata.R && cargo run --example parity_realdata",
  "threshold_relative_error": {threshold},
  "datasets": [
    {{
      "method": "MCP-counter",
      "dataset": "dataset_racle",
      "organism": "human",
      "citation": "Racle et al. 2017, eLife 6:e26476",
      "features_type": "HUGO_symbols",
      "input_genes": {mcp_genes},
      "populations": {mcp_pops},
      "samples": {mcp_samples},
      "worst_relative_error": {mcp_worst}
    }},
    {{
      "method": "mMCP-counter",
      "dataset": "dataset_petitprez",
      "organism": "mouse",
      "citation": "Petitprez et al. 2020, Genome Med 12:86",
      "features_type": "Gene.Symbol",
      "genome_version": "GCRm39",
      "input_genes": {mmcp_genes},
      "populations": {mmcp_pops},
      "samples": {mmcp_samples},
      "worst_relative_error": {mmcp_worst}
    }}
  ]
}}
"#,
        threshold = THRESHOLD,
        mcp_genes = mcp_genes,
        mcp_pops = mcp_res.populations.len(),
        mcp_samples = mcp_res.samples.len(),
        mcp_worst = mcp_worst,
        mmcp_genes = mmcp_genes,
        mmcp_pops = mmcp_res.populations.len(),
        mmcp_samples = mmcp_res.samples.len(),
        mmcp_worst = mmcp_worst,
    );
    if let Err(e) = fs::write(RESULTS_PATH, &json) {
        eprintln!("warning: could not write {RESULTS_PATH}: {e}");
    } else {
        println!("\nwrote {RESULTS_PATH}");
    }

    // --- gate ---
    let failed = mcp_worst >= THRESHOLD || mmcp_worst >= THRESHOLD;
    if failed {
        eprintln!("\nFAIL: worst relative error exceeds {THRESHOLD:e}");
        process::exit(1);
    }
    println!("\nOK: both methods within {THRESHOLD:e} relative error of R");
}

pub fn ncol(&self) -> usize

Number of columns (samples).

pub fn row_names(&self) -> &[String]

Row (feature) names.

Examples found in repository

examples/parity_realdata.rs (line 48)

fn worst_rel_err(res: &DeconvResult, expected_tsv: &str) -> f64 {
    let exp = read_tsv_matrix(expected_tsv); // rows = populations, cols = samples
    assert_eq!(
        res.populations,
        exp.row_names(),
        "population order mismatch"
    );
    assert_eq!(res.samples, exp.col_names(), "sample order mismatch");

    let mut worst = 0.0f64;
    for i in 0..res.populations.len() {
        for j in 0..res.samples.len() {
            let got = res.score(i, j);
            let want = exp.get(i, j);
            let rel = (got - want).abs() / want.abs().max(1e-300);
            worst = worst.max(rel);
        }
    }
    worst
}

pub fn col_names(&self) -> &[String]

Column (sample) names.

Examples found in repository

examples/parity_realdata.rs (line 51)

fn worst_rel_err(res: &DeconvResult, expected_tsv: &str) -> f64 {
    let exp = read_tsv_matrix(expected_tsv); // rows = populations, cols = samples
    assert_eq!(
        res.populations,
        exp.row_names(),
        "population order mismatch"
    );
    assert_eq!(res.samples, exp.col_names(), "sample order mismatch");

    let mut worst = 0.0f64;
    for i in 0..res.populations.len() {
        for j in 0..res.samples.len() {
            let got = res.score(i, j);
            let want = exp.get(i, j);
            let rel = (got - want).abs() / want.abs().max(1e-300);
            worst = worst.max(rel);
        }
    }
    worst
}

pub fn row_of(&self, name: &str) -> Option<usize>

First row index for a feature name, if present.

pub fn get(&self, row: usize, col: usize) -> f64

Value at (row, col).

Examples found in repository

examples/parity_realdata.rs (line 57)

fn worst_rel_err(res: &DeconvResult, expected_tsv: &str) -> f64 {
    let exp = read_tsv_matrix(expected_tsv); // rows = populations, cols = samples
    assert_eq!(
        res.populations,
        exp.row_names(),
        "population order mismatch"
    );
    assert_eq!(res.samples, exp.col_names(), "sample order mismatch");

    let mut worst = 0.0f64;
    for i in 0..res.populations.len() {
        for j in 0..res.samples.len() {
            let got = res.score(i, j);
            let want = exp.get(i, j);
            let rel = (got - want).abs() / want.abs().max(1e-300);
            worst = worst.max(rel);
        }
    }
    worst
}

Trait Implementations

impl Clone for ExprMatrix

fn clone(&self) -> ExprMatrix

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExprMatrix

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.