ability to make noise in comparator

Core/TransactionComparator/Logic/Comparator.cs

 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
 using TransactionComparator.Interface;
 using TransactionComparator.Logic;
@@ -10,30 +11,48 @@ namespace TransactionComparator
     {
         private List<Vertex> Minor;
         private List<Vertex> Major;
-
         private readonly bool Swapped;
-        private readonly List<Vertex> PairedMinor = new List<Vertex>();
-        private readonly List<Vertex> PairedMajor = new List<Vertex>();
+        private List<PairedTransactionContainer> PairedTransactions;
         public (List<IElement>, List<IElement>) GetRepetitivness()
         {
-            List<IElement> first = new List<IElement>(Minor.Count + PairedMinor.Count);
-            List<IElement> second = new List<IElement>(Major.Count + PairedMajor.Count);
+            List<IElement> first = new List<IElement>(Minor.Count + PairedTransactions.Count);
+            List<IElement> second = new List<IElement>(Major.Count + PairedTransactions.Count);
             foreach (Vertex e in Minor)
                 first.Add(e.Source);
-            foreach (Vertex e in PairedMinor)
-                first.Add(e.Source);
-
             foreach (Vertex e in Major)
                 second.Add(e.Source);
-            foreach (Vertex e in PairedMajor)
-                second.Add(e.Source);
+
+            //MakeNoise();
+
+            foreach (var pair in PairedTransactions)
+            {
+                first.Add(pair.First.Source);
+                second.Add(pair.Second.Source);
+            }
             return Swapped ? (second, first) : (first, second);
         }
+        private void MakeNoise()
+        {
+            int sum = PairedTransactions.Count + Minor.Count + Major.Count;
+            int realFalse = Major.Count;
+
+            int toNoise = ((int)Math.Round(sum / 2d))-realFalse;
+
+            //don't make noise for small amounts
+            //if ((double)toNoise / realFalse < 0.3)
+            //    return;
+
+            PairedTransactions.Sort((a, b) => -a.Distance.CompareTo(b.Distance));
+
+            for (int i = 0; i < toNoise; i++)
+                PairedTransactions[i].ResetRepetitivness();
+        }
+
         public Comparator(List<IElement> first, List<IElement> second)
         {
             if (first.Count < second.Count)
@@ -51,6 +70,8 @@ namespace TransactionComparator
             Minor.Sort();
             Major.Sort();
+
+            PairedTransactions = new List<PairedTransactionContainer>(Minor.Count);
         }
         public void Compare()
@@ -71,8 +92,9 @@ namespace TransactionComparator
         internal void WritePairs()
         {
-            for (int i = 0; i < PairedMajor.Count; i++)
-                Console.WriteLine($"{PairedMinor[i].Value} -> {PairedMajor[i].Value}");
+            MakeNoise();
+            foreach (var pair in PairedTransactions)
+                Console.WriteLine(pair.ToString());
         }
         internal void WriteUndetermined()
@@ -100,9 +122,7 @@ namespace TransactionComparator
                     continue;
                 }
-                Minor[i].Repetitive = Major[majorIndex].Repetitive = true;
-                PairedMinor.Add(Minor[i]);
-                PairedMajor.Add(Major[majorIndex]);
+                PairedTransactions.Add(new PairedTransactionContainer(Minor[i], Major[majorIndex]));
                 Major[majorIndex] = null;
             }

Core/TransactionComparator/Logic/PairedTransactionContainer.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TransactionComparator.Logic
+{
+    class PairedTransactionContainer
+    {
+        public Vertex First;
+        public Vertex Second;
+        public readonly double Distance;
+
+        private bool RepetivnessReseted = false;
+
+        public PairedTransactionContainer(Vertex first, Vertex second)
+        {
+            first.Repetitive = second.Repetitive = true;
+
+            First = first;
+            Second = second;
+
+            // make distance as ratio of two elements
+            double sizeOfFirst = Math.Abs(First.Value);
+            double sizeOfSecond = Math.Abs(Second.Value);
+
+            Distance = sizeOfFirst > sizeOfSecond ? sizeOfFirst / sizeOfSecond : sizeOfSecond /sizeOfFirst;
+        }
+
+        public void ResetRepetitivness()
+        {
+            First.Repetitive = Second.Repetitive = false;
+            RepetivnessReseted = true;
+        }
+
+        public override string ToString()
+        {
+            return $"{First.Value} -> {Second.Value} ({Distance}), noise: {RepetivnessReseted}";
+        }
+    }
+}