added-numbers-to-distinguish-has-ignore-keyword-and-has-date-time-original

moved-container-to-new-project-to-prepare-to-remove-property-file

added-logic-to-rename-to-3-and-7-like-should-ignore-for-missing-date-time-original

Property/Models/Stateless/Property.cs

@@ -366,4 +366,112 @@ internal partial class Property
         return new(property?.DateTimeOriginal, dateTimes, property?.Id, message);
     }
 
+    internal static double GetStandardDeviation(List<long> values, double average)
+    {
+        double result = 0;
+        if (values.Count == 0)
+            throw new Exception("Collection must have at least one value!");
+        double sum = values.Sum(l => (l - average) * (l - average));
+        result = Math.Sqrt(sum / values.Count);
+        return result;
+    }
+
+    private static long GetThreeStandardDeviationHigh(ref List<long> ticksCollection, long min)
+    {
+        long result;
+        ticksCollection = (from l in ticksCollection select l - min).ToList();
+        double sum = ticksCollection.Sum();
+        double average = sum / ticksCollection.Count;
+        double standardDeviation = GetStandardDeviation(ticksCollection, average);
+        result = (long)Math.Ceiling(average + min + (standardDeviation * 3));
+        return result;
+    }
+
+    internal static TimeSpan GetThreeStandardDeviationHigh(int minimum, Container.Models.Container container)
+    {
+        TimeSpan result;
+        DateTime? minimumDateTime;
+        List<long> ticksCollection = [];
+        foreach (Shared.Models.Item item in container.Items)
+        {
+            if (item.Property is null)
+                continue;
+            minimumDateTime = Shared.Models.Methods.IProperty.GetMinimumDateTime(item.Property);
+            if (minimumDateTime is null)
+                continue;
+            ticksCollection.Add(minimumDateTime.Value.Ticks);
+        }
+        long threeStandardDeviationHigh;
+        long min;
+        if (ticksCollection.Count == 0)
+            min = 0;
+        else
+            min = ticksCollection.Min();
+        if (ticksCollection.Count < minimum)
+            threeStandardDeviationHigh = long.MaxValue;
+        else
+            threeStandardDeviationHigh = GetThreeStandardDeviationHigh(ref ticksCollection, min);
+        result = new TimeSpan(threeStandardDeviationHigh - min);
+        return result;
+    }
+
+    internal static (int, List<DateTime>, List<Shared.Models.Item>) Get(Container.Models.Container container, TimeSpan threeStandardDeviationHigh, int i)
+    {
+        List<Shared.Models.Item> results = [];
+        int j = i;
+        long? ticks;
+        TimeSpan timeSpan;
+        Shared.Models.Item item;
+        DateTime? minimumDateTime;
+        Shared.Models.Item nextItem;
+        DateTime? nextMinimumDateTime;
+        List<DateTime> dateTimes = [];
+        for (; j < container.Items.Count; j++)
+        {
+            ticks = null;
+            item = container.Items[j];
+            if (item.Property is null)
+                continue;
+            minimumDateTime = Shared.Models.Methods.IProperty.GetMinimumDateTime(item.Property);
+            if (minimumDateTime is null)
+                continue;
+            for (int k = j + 1; k < container.Items.Count; k++)
+            {
+                nextItem = container.Items[k];
+                if (nextItem.Property is null)
+                    continue;
+                nextMinimumDateTime = Shared.Models.Methods.IProperty.GetMinimumDateTime(nextItem.Property);
+                if (nextMinimumDateTime is null)
+                    continue;
+                ticks = nextMinimumDateTime.Value.Ticks;
+                break;
+            }
+            results.Add(item);
+            dateTimes.Add(minimumDateTime.Value);
+            if (ticks.HasValue)
+            {
+                timeSpan = new(ticks.Value - minimumDateTime.Value.Ticks);
+                if (timeSpan > threeStandardDeviationHigh)
+                    break;
+            }
+        }
+        return new(j, dateTimes, results);
+    }
+
+    internal static bool Any(Container.Models.Container[] containers)
+    {
+        bool result = false;
+        foreach (Container.Models.Container container in containers)
+        {
+            if (container.Items.Count == 0)
+                continue;
+            if ((from l in container.Items where l.Any() select true).Any())
+            {
+                result = true;
+                break;
+            }
+        }
+        return result;
+    }
+
 }