fix edge case in inline linear solve

Author: oscardssmith

src/utils.jl

@@ -340,14 +340,19 @@ function get_new_mm(
         push!(final_row_cols, new_row_col_i[indices[1]])
         push!(final_row_vals, new_row_val_i[indices[1]])
         for i in Iterators.drop(eachindex(indices), 1)
-            if new_row_col_i[indices[i]] == new_row_col_i[indices[i - 1]]
+            col = new_row_col_i[indices[i]]
+            # Compare against the last *retained* column rather than the previous
+            # sorted entry: a prior cancellation may have `pop!`ed the matching
+            # entry, in which case the remaining duplicates of `col` must start a
+            # fresh accumulator instead of folding into an unrelated column.
+            if !isempty(final_row_cols) && col == final_row_cols[end]
                 final_row_vals[end] += new_row_val_i[indices[i]]
                 if iszero(final_row_vals[end])
                     pop!(final_row_cols)
                     pop!(final_row_vals)
                 end
             else
-                push!(final_row_cols, new_row_col_i[indices[i]])
+                push!(final_row_cols, col)
                 push!(final_row_vals, new_row_val_i[indices[i]])
             end
         end

test/runtests.jl

@@ -29,4 +29,34 @@ include("carpanzano_tearing.jl")
     @test mm2.ncols == 2
     aliases = Dict(1 => sparse([0, 0, 2, 1]))
     @test_throws SSel.BadMMAliasError SSel.get_new_mm(aliases, old_to_new_eq, old_to_new_var, mm)
+
+    # Three entries collapse onto the same column, and the first two cancel to
+    # zero. The remaining duplicate must survive as a fresh entry rather than
+    # being folded into the (now popped) accumulator.
+    # Row `[2 1 1]`: var1 retained, var2 -> -2*var1, var3 -> 3*var1.
+    # Contributions to new col 1: 2 (direct) + 1*(-2) + 1*3 = 3.
+    mm = SSel.CLIL.SparseMatrixCLIL([2 1 1])
+    old_to_new_eq = [1]
+    old_to_new_var = [1, 0, 0]
+    aliases = Dict(2 => sparse([-2, 0, 0]), 3 => sparse([3, 0, 0]))
+    mm2 = SSel.get_new_mm(aliases, old_to_new_eq, old_to_new_var, mm)
+    @test mm2.nzrows == [1]
+    @test mm2.row_cols == [[1]]
+    @test mm2.row_vals == [[3]]
+    @test mm2.ncols == 1
+
+    # Same cancellation, but with a distinct retained column already present
+    # before the cancelling group. The surviving duplicate must not leak into
+    # the earlier column.
+    # Row `[7 2 1 1]`: var1 -> col1, var2 -> col2, var3 -> -2*var2, var4 -> 5*var2.
+    # col1 = 7, col2 = 2 + 1*(-2) + 1*5 = 5.
+    mm = SSel.CLIL.SparseMatrixCLIL([7 2 1 1])
+    old_to_new_eq = [1]
+    old_to_new_var = [1, 2, 0, 0]
+    aliases = Dict(3 => sparse([0, -2, 0, 0]), 4 => sparse([0, 5, 0, 0]))
+    mm2 = SSel.get_new_mm(aliases, old_to_new_eq, old_to_new_var, mm)
+    @test mm2.nzrows == [1]
+    @test mm2.row_cols == [[1, 2]]
+    @test mm2.row_vals == [[7, 5]]
+    @test mm2.ncols == 2
 end