fix aggregate networks

Author: ncborcherding

DESCRIPTION

@@ -1,6 +1,6 @@
 Package: immApex
 Title: Tools for Adaptive Immune Receptor Sequence-Based Machine and Deep Learning
-Version: 1.4.3
+Version: 1.4.4
 Authors@R: c(
     person(given = "Nick", family = "Borcherding", role = c("aut", "cre"), email = "ncborch@gmail.com"))
 Description: A set of tools to for machine and deep learning in R from amino acid and nucleotide sequences focusing on adaptive immune receptors. The package includes pre-processing of sequences, unifying gene nomenclature usage, encoding sequences, and combining models. This package will serve as the basis of future immune receptor sequence functions/packages/models compatible with the scRepertoire ecosystem.

NEWS.md

@@ -1,3 +1,8 @@
+# immApex VERSION 1.4.4
+
+## BUGS
+* Fixed `buildNetworks()` issue that aggregates similarity for duplicated sequences. 
+
 # immApex VERSION 1.4.3
 
 ## NEW FEATURES

R/buildNetwork.R

@@ -10,10 +10,10 @@
 #' inside `input.data`. Ignored when `NULL` and `seq_col` is non-`NULL`.
 #' @param seq_col,v_col,j_col Column names to use when `input.data` is given. 
 #' By default the function looks for common AIRR names (`junction_aa`, 
-#' `cdr3`, `v_call`, `j_call`).
+#' `cdr3`, `sequence`, `seq`).
 #' @param threshold >= 1 for absolute distance **or** 0 < x <= 1 for relative.
 #' When using normalized distances (`normalize != "none"`), this typically 
-#' should be a value between 0 and 1 (e.g., 0.9 for 10 percent dissimilarity).
+#' should be a value between 0.0 and 1.0 (e.g., 0.1 for 10 percent dissimilarity).
 #' @param filter.v Logical; require identical V when `TRUE`.
 #' @param filter.j Logical; require identical J when `TRUE`.
 #' @param ids Optional character labels; recycled from row-names if missing.
@@ -96,7 +96,7 @@
 #'                       dist_type  = "damerau",
 #'                       filter.v   = TRUE)
 #'
-#' @return edge-list `data.frame` **or** sparse adjacency `dgCMatrix`
+#' @return edge-list `data.frame` **or** sparse adjacency `dgCMatrix` of distances
 #' @importFrom Matrix sparseMatrix
 #' @export
 buildNetwork <- function(input.data        = NULL,
@@ -176,7 +176,7 @@ buildNetwork <- function(input.data        = NULL,
     if (n > 0) {
       first_len <- nchar(seq_vec[1])
       if (any(nchar(seq_vec) != first_len)) {
-        warning("Hamming distance requires equal-length sequences. ", 
+        message("Hamming distance requires equal-length sequences. ", 
                 "Pairs of unequal length will be assigned max distance.")
       }
     }
@@ -208,13 +208,30 @@ buildNetwork <- function(input.data        = NULL,
     normalize    = normalize  
   )
 
+  # Remove Duplicate Edges
+  if (nrow(edge_df) > 0) {
+    edge_key <- paste(
+      pmin(edge_df$from, edge_df$to),
+      pmax(edge_df$from, edge_df$to),
+      sep = "\t"
+    )
+    
+    # Check if there are duplicates
+    if (anyDuplicated(edge_key)) {
+      agg_idx <- !duplicated(edge_key)
+      edge_df <- edge_df[agg_idx, , drop = FALSE]
+    }
+  }
+  
   if (output == "edges")
     return(edge_df)
 
   ## 6. Convert edge list to sparse adjacency 
   if (!requireNamespace("Matrix", quietly = TRUE))
     stop("Matrix package required for sparse output.")
 
+  # =========================================================================
+  
   all_ids <- sort(unique(c(edge_df$from, edge_df$to)))
   idx_from <- match(edge_df$from, all_ids)
   idx_to   <- match(edge_df$to,   all_ids)

man/buildNetwork.Rd

@@ -288,8 +288,23 @@ DataFrame fast_edge_list(CharacterVector seqs,
       if (max_l == 0) continue;
 
       int maxd;
-      if (thresh >= 1.0) maxd = (int)thresh;
-      else maxd = (int)((1.0 - thresh) * max_l); 
+      if (thresh >= 1.0) {
+        // Absolute distance threshold
+        maxd = (int)thresh;
+      } else {
+        // Normalized distance threshold - use same length as normalization
+        double norm_len;
+        if (normalize == "maxlen") {
+          norm_len = (double)max_l;
+        } else if (normalize == "length") {
+          norm_len = (lens[i] + lens[k]) / 2.0;
+        } else {
+          // normalize == "none": interpret threshold as fraction of max_l
+          norm_len = (double)max_l;
+        }
+        maxd = (int)(thresh * norm_len);
+      }
+      // =====================================================================
 
       if (metric != "nw" && metric != "sw" && std::abs(lens[i] - lens[k]) > maxd) continue;
 
@@ -310,6 +325,11 @@ DataFrame fast_edge_list(CharacterVector seqs,
         if (normalize == "maxlen") fd /= max_l;
         else if (normalize == "length") fd /= ((lens[i]+lens[k])/2.0);
 
+        if (thresh < 1.0 && normalize != "none" && fd > thresh) {
+          continue;  // Skip edges that exceed normalized threshold
+        }
+        // =====================================================================
+        
         loc_f.push_back(lbl[i]);
         loc_t.push_back(lbl[k]);
         loc_d_vec.push_back(fd);
@@ -326,4 +346,4 @@ DataFrame fast_edge_list(CharacterVector seqs,
   }
 
   return DataFrame::create(_["from"] = out_from, _["to"] = out_to, _["dist"] = out_d, _["stringsAsFactors"] = false);
-}
+}

src/fastEditEdges.cpp

@@ -55,6 +55,7 @@ test_that("Backward compatibility - relative threshold", {
     input.data = data,
     seq_col = "junction_aa",
     threshold = 0.9,
+    normalize = "length",
     filter.v = TRUE
   )
 
@@ -466,22 +467,4 @@ test_that("Invalid substitution matrix rejected", {
   )
 })
 
-test_that("Hamming requires equal length", {
-  data <- data.frame(
-    sequence_id = c("seq1", "seq2", "seq3"),
-    junction_aa = c("AAAA", "BBBB", "CCCCC"),  # Different lengths
-    v_call = rep("IGHV1", 3),
-    stringsAsFactors = FALSE
-  )
-  
-  expect_warning(
-    edges <- buildNetwork(
-      input.data = data,
-      seq_col = "junction_aa",
-      threshold = 2,
-      dist_type = "hamming",
-      filter.v = TRUE
-    ),
-    "equal-length"
-  )
-})
+