Feature issue#4581 Maximum Drawdown Recovery Time.

Common/Statistics/DrawdownPercentageDrawdownDatesHighValueDTO.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace QuantConnect.Statistics
+{
+    internal class DrawdownPercentageDrawdownDatesHighValueDTO
+    {
+        public decimal DrawdownPercent { get; }
+        public List<DateTime> MaxDrawdownEndDates { get; }
+        public decimal HighPrice { get; }
+
+        public DrawdownPercentageDrawdownDatesHighValueDTO(decimal drawdownPercent, List<DateTime> maxDrawdownEndDates, decimal recoveryThresholdPrice)
+        {
+            DrawdownPercent = drawdownPercent;
+            MaxDrawdownEndDates = maxDrawdownEndDates;
+            HighPrice = recoveryThresholdPrice;
+        }
+    }
+}

Common/Statistics/PerformanceMetrics.cs

@@ -156,5 +156,11 @@ public static class PerformanceMetrics
         /// The average Portfolio Turnover
         /// </summary>
         public const string PortfolioTurnover = "Portfolio Turnover";
+
+        /// <summary>
+        /// The recovery time of the maximum drawdown.
+        /// </summary>
+        public const string MaxDrawdownRecovery = "Maximum Drawdown Recovery";
+
     }
 }

Common/Statistics/PortfolioStatistics.cs

@@ -185,6 +185,13 @@ public class PortfolioStatistics
         [JsonConverter(typeof(JsonRoundingConverter))]
         public decimal ValueAtRisk95 { get; set; }
 
+        /// <summary>
+        /// The recovery time of the maximum drawdown.
+        /// </summary>
+        [JsonConverter(typeof(JsonRoundingConverter))]
+        public decimal MaximumDrawdownRecovery { get; set; }
+
+
         /// <summary>
         /// Initializes a new instance of the <see cref="PortfolioStatistics"/> class
         /// </summary>
@@ -308,6 +315,8 @@ public PortfolioStatistics(
 
             ValueAtRisk99 = GetValueAtRisk(listPerformance, tradingDaysPerYear, 0.99d);
             ValueAtRisk95 = GetValueAtRisk(listPerformance, tradingDaysPerYear, 0.95d);
+
+            MaximumDrawdownRecovery = (decimal)Statistics.MaxDrawdownRecoveryTime(equity, 3);
         }
 
         /// <summary>

Common/Statistics/Statistics.cs

@@ -18,6 +18,7 @@
 using System.IO;
 using System.Linq;
 using System.Net;
+using MathNet.Numerics;
 using MathNet.Numerics.Distributions;
 using MathNet.Numerics.Statistics;
 using QuantConnect.Logging;
@@ -38,24 +39,7 @@ public class Statistics
         /// <returns></returns>
         public static decimal DrawdownPercent(SortedDictionary<DateTime, decimal> equityOverTime, int rounding = 2)
         {
-            var dd = 0m;
-            try
-            {
-                var lPrices = equityOverTime.Values.ToList();
-                var lDrawdowns = new List<decimal>();
-                var high = lPrices[0];
-                foreach (var price in lPrices)
-                {
-                    if (price >= high) high = price;
-                    lDrawdowns.Add((price/high) - 1);
-                }
-                dd = Math.Round(Math.Abs(lDrawdowns.Min()), rounding);
-            }
-            catch (Exception err)
-            {
-                Log.Error(err);
-            }
-            return dd;
+            return DrawdownPercentDrawdownDatesHighValue(equityOverTime, rounding).DrawdownPercent;
         }
 
         /// <summary>
@@ -281,6 +265,88 @@ public static decimal DrawdownPercent(decimal current, decimal high, int roundin
             return Math.Round(drawdownPercentage, roundingDecimals);
         }
 
+        /// <summary>
+        /// Returns Drawdown percentage, the dates the drawdown ended and the price value at which the drawdowns started.
+        /// </summary>
+        /// <param name="equityOverTime"></param>
+        /// <param name="rounding"></param>
+        /// <returns></returns>
+        private static DrawdownPercentageDrawdownDatesHighValueDTO DrawdownPercentDrawdownDatesHighValue(SortedDictionary<DateTime, decimal> equityOverTime, int rounding = 2)
+        {
+            var dd = 0m;
+            var maxDrawdownDates = new List<DateTime>();
+            var highValue = 0m;
+            try
+            {
+                var lPrices = equityOverTime.ToList();
+                var lDrawdowns = new List<decimal>();
+                var high = lPrices[0].Value;
+                decimal maxDrawdown = 0;
+
+                foreach (var timePricePair in lPrices)
+                {
+                    if (timePricePair.Value >= high) high = timePricePair.Value;
+                    var drawdown = (timePricePair.Value / high) - 1;
+
+                    if (drawdown < maxDrawdown)
+                    {
+                        maxDrawdown = drawdown;
+                        maxDrawdownDates.Clear();
+                        maxDrawdownDates.Add(timePricePair.Key);
+                        highValue = high;
+                    }
+                    else if (drawdown == maxDrawdown && maxDrawdownDates.Count > 0)
+                    {
+                        maxDrawdownDates.Add(timePricePair.Key);
+                    }
+
+                    lDrawdowns.Add(drawdown);
+                }
+                dd = Math.Round(Math.Abs(maxDrawdown), rounding);
+            }
+            catch (Exception err)
+            {
+                Log.Error(err);
+            }
+            return new DrawdownPercentageDrawdownDatesHighValueDTO(dd, maxDrawdownDates, highValue);
+        }
+
+        /// <summary>
+        /// Calculates the recovery time of the maximum drawdown in days. If there are multiple maximum drawdown, it picks the longer drawdown to report.
+        /// </summary>
+        /// <param name="equityOverTime">Price Data</param>
+        /// <param name="rounding">Amount of decimals to round the result to.</param>
+        /// <returns>Recovery time of maximum drawdown in days.</returns>
+        public static decimal MaxDrawdownRecoveryTime(SortedDictionary<DateTime, decimal> equityOverTime, int rounding = 2)
+        {
+            var drawdownInfo = DrawdownPercentDrawdownDatesHighValue(equityOverTime);
+
+            if (drawdownInfo.MaxDrawdownEndDates.Count == 0)
+            {
+                return 0; // No drawdown occurred
+            }
+
+            var recoveryThresholdPrice = drawdownInfo.HighPrice;
+            decimal longestRecoveryTime = 0;
+
+            foreach (var maxDrawdownDate in drawdownInfo.MaxDrawdownEndDates)
+            {
+                var recoveryDate = equityOverTime
+                    .Where(kvp => kvp.Key > maxDrawdownDate && kvp.Value >= recoveryThresholdPrice)
+                    .Select(kvp => kvp.Key)
+                    .DefaultIfEmpty(DateTime.MaxValue)
+                    .Min();
+
+                if (recoveryDate != DateTime.MaxValue)
+                {
+                    var recoveryTime = (decimal)(recoveryDate - maxDrawdownDate).TotalDays;
+                    longestRecoveryTime = Math.Max(longestRecoveryTime, recoveryTime);
+                }
+            }
+
+            return Math.Round(longestRecoveryTime, rounding);
+        }
+
     } // End of Statistics
 
 } // End of Namespace

Common/Statistics/StatisticsBuilder.cs

@@ -240,7 +240,8 @@ private static Dictionary<string, string> GetSummary(AlgorithmPerformance totalP
                 { PerformanceMetrics.TotalFees, accountCurrencySymbol + totalFees.ToStringInvariant("0.00") },
                 { PerformanceMetrics.EstimatedStrategyCapacity, accountCurrencySymbol + capacity.RoundToSignificantDigits(2).ToStringInvariant() },
                 { PerformanceMetrics.LowestCapacityAsset, lowestCapacitySymbol != Symbol.Empty ? lowestCapacitySymbol.ID.ToString() : "" },
-                { PerformanceMetrics.PortfolioTurnover, Math.Round(totalPerformance.PortfolioStatistics.PortfolioTurnover.SafeMultiply100(), 2).ToStringInvariant() + "%" }
+                { PerformanceMetrics.PortfolioTurnover, Math.Round(totalPerformance.PortfolioStatistics.PortfolioTurnover.SafeMultiply100(), 2).ToStringInvariant() + "%" },
+                { PerformanceMetrics.MaxDrawdownRecovery, totalPerformance.PortfolioStatistics.MaximumDrawdownRecovery.ToStringInvariant() + " day(s)."},
             };
         }