Mz spectrum weighted merge within mz tolerance

mzLib/MassSpectrometry/ExtensionMethods.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using MzLibUtil;
+
+namespace MassSpectrometry
+{
+    public class ExtensionMethods
+    {
+        public static void MergeMzAndIntensityValuesForAnyMzsWithinTolerance(ref double[] mzArray, ref double[] intensityArray, PpmTolerance ppmTolerance)
+        {
+            List<double> newMzArray = new List<double>();
+            List<double> newIntensityArray = new List<double>();
+
+            List<int> indiciesToMerge = new List<int>();
+            for (int i = 0; i < mzArray.Length; i++)
+            {
+                if (i < (mzArray.Length - 1) && ppmTolerance.Within(mzArray[i], mzArray[i + 1])) // two mzValues are close enough to merge
+                {
+                    indiciesToMerge.Add(i);
+                    indiciesToMerge.Add(i + 1);
+                }
+                else // mzValues are NOT close enough to merge so we merge any that we've collected so far.
+                {
+                    if (indiciesToMerge.Any())
+                    {
+                        newMzArray.Add(GetWeightedMz(indiciesToMerge.DistinctBy(i => i).ToList(), mzArray.ToList(), intensityArray.ToList()));
+                        newIntensityArray.Add(GetIntensityAverage(indiciesToMerge, mzArray, intensityArray));
+                        indiciesToMerge.Clear(); //we clear this array because we have merged a contiguous group and can begin again with the next group
+                    }
+                    else
+                    {
+                        newMzArray.Add(mzArray[i]);
+                        newIntensityArray.Add(intensityArray[i]);
+                    }
+                }
+            }
+
+            mzArray = newMzArray.ToArray();
+            intensityArray = newIntensityArray.ToArray();
+        }
+        private static double GetIntensityAverage(List<int> indiciesToMerge, double[] mzArray, double[] intensityArray)
+        {
+            double intensitySum = 0;
+            foreach (var index in indiciesToMerge)
+            {
+                intensitySum += intensityArray[index];
+            }
+            return (intensitySum / (double)indiciesToMerge.Count);
+        }
+
+        private static double GetWeightedMz(List<int> indiciesToMerge, List<double> mzArray, List<double> intensityArray)
+        {
+            double weightedMz = 0;
+            double intensitySum = 0;
+            foreach (var index in indiciesToMerge)
+            {
+                weightedMz += mzArray[index] * intensityArray[index];
+                intensitySum += intensityArray[index];
+            }
+            return (weightedMz / intensitySum);
+        }
+
+        public static double[] MergeTwoSortedArraysIntoSortedArray(double[] sortedArrayOne, double[] sortedArrayTwo)
+        {
+            double[] mergedSortedArray = new double[sortedArrayOne.Length + sortedArrayTwo.Length];
+            int oneIndex = 0;
+            int twoIndex = 0;
+
+            for (int i = 0; i < mergedSortedArray.Length; i++)
+            {
+                if (oneIndex<sortedArrayOne.Length && sortedArrayOne[oneIndex] < sortedArrayTwo[twoIndex])
+                {
+                    mergedSortedArray[i] = sortedArrayOne[oneIndex];
+                    oneIndex++;
+                }
+                else
+                {
+                    if (twoIndex < sortedArrayTwo.Length)
+                    {
+                        mergedSortedArray[i] = sortedArrayTwo[twoIndex];
+                        twoIndex++;
+                    }
+                }
+            }
+            return mergedSortedArray;
+        }
+
+        public (T[], U[]) MergeSortedArrays<T, U>(T[][] arraysToBeSorted, U[][] valuesToBePreserved) where T : IComparable
+        {
+            int[] minPointerArray = new int[arraysToBeSorted.Length];
+            int sumOfAllArrayLengths = 0;
+            for (int i = 0; i < arraysToBeSorted.Length; i++)
+            {
+                sumOfAllArrayLengths += arraysToBeSorted[i].Length;
+            }
+            T[] = new T[sumOfAllArrayLengths];
+            U[] = new U[sumOfAllArrayLengths];
+            Array<T> t = new int()
+        }
+    }
+}

mzLib/MassSpectrometry/MzSpectra/MzSpectrum.cs

@@ -22,10 +22,13 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.ComponentModel.Design;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Text.Json;
+using MassSpectrometry.MzSpectra;
+using ClassExtensions = Chemistry.ClassExtensions;
 
 namespace MassSpectrometry
 {
@@ -800,5 +803,21 @@ private MzPeak GeneratePeak(int index)
         {
             return new MzPeak(XArray[index], YArray[index]);
         }
+        /// <summary>
+        /// Method takes a list of mz and intensity values from a spectrum and merges those pairs of mzs and intensities when the difference in the mzs is less than specified tolerance
+        /// </summary>
+        /// <param name="mzArray"></param>
+        /// <param name="intensityArray"></param>
+        /// <param name="ppmTolerance"></param>
+        /// <returns></returns>
+        public void MergeMzAndIntensityValuesForAnyMzsWithinTolerance(PpmTolerance ppmTolerance)
+        {
+            var mzArray = this.XArray;
+            var intensityArray= this.YArray;
+            ExtensionMethods.MergeMzAndIntensityValuesForAnyMzsWithinTolerance(ref mzArray, ref intensityArray, ppmTolerance);
+            this.XArray = mzArray;
+            this.YArray = intensityArray;
+        }
+
     }
 }

mzLib/Omics/Fragmentation/MatchedFragmentIon.cs

@@ -76,7 +76,7 @@ public override bool Equals(object obj)
         {
             MatchedFragmentIon other = (MatchedFragmentIon)obj;
 
-            return this.NeutralTheoreticalProduct.Equals(other.NeutralTheoreticalProduct)
+            return this.NeutralTheoreticalProduct.Equals(other.NeutralTheoreticalProduct as Product)
                 && this.Charge == other.Charge
                 && this.Mz == other.Mz
                 && this.Intensity == other.Intensity;

mzLib/Test/TestMzSpectrum.cs

@@ -0,0 +1,31 @@
+using MassSpectrometry;
+using MzLibUtil;
+using NUnit.Framework;
+using TopDownProteomics.IO.MzIdentMl;
+
+namespace Test
+{
+    [TestFixture]
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    public sealed class TestMzSpectrum
+    {
+
+        [Test]
+        public void Bubba()
+        {
+            double[] mzs = new double[3] { 1,1.0000001, 1.0000002 };
+            double[] intensities = new double[3] { 1,2,3 };
+            bool shouldCopy = false;
+            MzSpectrum s = new MzSpectrum(mzs,intensities,shouldCopy);
+
+            s.MergeMzAndIntensityValuesForAnyMzsWithinTolerance(new PpmTolerance(0.01));
+        }
+
+        [Test]
+        public void Bubba2()
+        {
+            var j = ExtensionMethods.MergeTwoSortedArraysIntoSortedArray(new double[] { 2, 4, 6, }, new double[] { 1, 3, 5, 7, 8, 9, 10, 11, 12 });
+            CollectionAssert.AreEquivalent(new double[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }, j);
+        }
+    }
+}