commands/normalize: Convert features lengths to u32

Author: zaeleus

Diff for: src/commands/normalize.rs

@@ -1,4 +1,5 @@
 use std::{
+    collections::HashMap,
     fs::File,
     io::{self, BufReader, BufWriter, Write},
     path::{Path, PathBuf},
@@ -9,8 +10,8 @@ use tracing::info;
 
 use crate::{
     counts,
-    normalization::{self, calculate_feature_lengths, fpkm, tpm},
-    read_features,
+    normalization::{self, fpkm, tpm},
+    read_features, Feature,
 };
 
 #[derive(Debug, Error)]
@@ -57,8 +58,7 @@ where
 
     info!(normalization_method = ?method, "normalizing counts");
 
-    let lengths =
-        calculate_feature_lengths(&features, &names).map_err(NormalizeError::Normalization)?;
+    let lengths = calculate_feature_lengths(&features, &names).map_err(NormalizeError::Io)?;
 
     let normalized_counts = match method {
         normalization::Method::Fpkm => fpkm::normalize(&lengths, &counts),
@@ -84,6 +84,17 @@ where
     counts::read(&mut reader).map_err(NormalizeError::ReadCounts)
 }
 
+fn calculate_feature_lengths(
+    features: &HashMap<String, Vec<Feature>>,
+    names: &[String],
+) -> io::Result<Vec<u32>> {
+    normalization::calculate_feature_lengths(features, names)
+        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?
+        .into_iter()
+        .map(|n| u32::try_from(n).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e)))
+        .collect()
+}
+
 fn write_normalized_counts<W>(writer: &mut W, names: &[String], values: &[f64]) -> io::Result<()>
 where
     W: Write,

Diff for: src/normalization/fpkm.rs

@@ -1,4 +1,4 @@
-pub fn normalize(lengths: &[usize], counts: &[u32]) -> Vec<f64> {
+pub fn normalize(lengths: &[u32], counts: &[u32]) -> Vec<f64> {
     let sum = counts.iter().copied().map(f64::from).sum();
 
     lengths
@@ -8,9 +8,9 @@ pub fn normalize(lengths: &[usize], counts: &[u32]) -> Vec<f64> {
         .collect()
 }
 
-fn calculate_fpkm(count: u32, length: usize, sum: f64) -> f64 {
+fn calculate_fpkm(count: u32, length: u32, sum: f64) -> f64 {
     assert!(length > 0);
-    (f64::from(count) * 1e9) / (length as f64 * sum)
+    (f64::from(count) * 1e9) / (f64::from(length) * sum)
 }
 
 #[cfg(test)]

Diff for: src/normalization/tpm.rs

@@ -1,10 +1,10 @@
-pub fn normalize(lengths: &[usize], counts: &[u32]) -> Vec<f64> {
+pub fn normalize(lengths: &[u32], counts: &[u32]) -> Vec<f64> {
     let length_normalized_counts: Vec<_> = lengths
         .iter()
         .zip(counts)
         .map(|(length, count)| {
             assert!(*length > 0);
-            f64::from(*count) / (*length as f64)
+            f64::from(*count) / f64::from(*length)
         })
         .collect();