Improved XML comments, efficiency improvements to several methods, new time series download methods.

Author: HadenSmith

Numerics/Data/Statistics/Probability.cs

@@ -1017,7 +1017,6 @@ public static double IndependentExclusive(IList<double> probabilities, int[] ind
 
         /// <summary>
         /// Returns an array of exclusive probabilities of multiple events occurring assuming independence.
-        /// This method applies the <see cref="IndependentExclusive"/> method to multiple event combinations from the indicators array.
         /// </summary>
         /// <param name="probabilities">An array of probabilities for each event.</param>
         /// <param name="indicators">A 2D array of indicators, where each row represents a combination of events, and 0 means the event did not occur and 1 means the event did occur.</param>

Numerics/Data/Statistics/Statistics.cs

@@ -100,16 +100,16 @@ public static double Minimum(IList<double> data)
             if (data == null) throw new ArgumentNullException(nameof(data));
             if (data.Count == 0) return double.NaN;
 
-            double min = double.MaxValue;
+            double min = double.PositiveInfinity;
             for (int i = 0; i < data.Count; i++)
             {
-                if (data[i] < min || double.IsNaN(data[i]))
-                {
+                if (double.IsNaN(data[i]))
+                    return double.NaN;
+                if (data[i] < min)
                     min = data[i];
-                }
             }
 
-            return min;
+            return double.IsPositiveInfinity(min) ? double.NaN : min;
         }
 
         /// <summary>
@@ -122,16 +122,16 @@ public static double Maximum(IList<double> data)
             if (data == null) throw new ArgumentNullException(nameof(data));
             if (data.Count == 0) return double.NaN;
 
-            double max = double.MinValue;
+            double max = double.NegativeInfinity;
             for (int i = 0; i < data.Count; i++)
             {
-                if (data[i] > max || double.IsNaN(data[i]))
-                {
+                if (double.IsNaN(data[i]))
+                    return double.NaN;
+                if (data[i] > max)
                     max = data[i];
-                }
             }
 
-            return max;
+            return double.IsNegativeInfinity(max) ? double.NaN : max;
         }
 
         /// <summary>
@@ -190,7 +190,11 @@ public static double GeometricMean(IList<double> data)
 
             double sum = 0;
             for (int i = 0; i < data.Count; i++)
+            {
+                if (data[i] <= 0) return double.NaN;
                 sum += Math.Log(data[i]);
+            }
+
             return Math.Exp(sum / data.Count);
         }
 

Numerics/Data/Time Series/Support/TimeSeriesDownload.cs

@@ -392,7 +392,6 @@ public virtual double[] CentralMoments(int steps = 300)
         /// </summary>
         /// <param name="a">The lower integration limit, a.</param>
         /// <param name="b">The upper integration limit, b.</param>
-        /// <param name="steps">Number of integration steps. Default = 300.</param>
         /// <summary>
         /// Returns conditional central moments (up to 4th order) between [a, b].
         /// </summary>

Numerics/Distributions/Univariate/Base/UnivariateDistributionBase.cs

@@ -501,7 +501,7 @@ public override UnivariateDistributionBase Clone()
         }
 
 
-        // <summary>
+        /// <summary>
         /// Convolves two empirical distributions using FFT.
         /// </summary>
         /// <param name="dist1">The first empirical distribution.</param>

Numerics/Distributions/Univariate/EmpiricalDistribution.cs

@@ -416,6 +416,13 @@ public override double[] MaximumOfParameters
         /// </summary>
         private interface IKernel
         {
+            /// <summary>
+            /// Evaluates the kernel function at the specified point.
+            /// </summary>
+            /// <param name="x">The point at which to evaluate the kernel.</param>
+            /// <returns>
+            /// The kernel value.
+            /// </returns>
             double Function(double x);
         }
 
@@ -424,6 +431,17 @@ private interface IKernel
         /// </summary>
         private class EpanechnikovKernel : IKernel
         {
+            /// <summary>
+            /// Evaluates the Epanechnikov kernel function at the specified point.
+            /// </summary>
+            /// <param name="x">The point at which to evaluate the kernel.</param>
+            /// <returns>
+            /// The kernel value: 0.75(1-x²) for |x| ≤ 1, and 0 otherwise.
+            /// </returns>
+            /// <remarks>
+            /// The Epanechnikov kernel is optimal in minimizing the mean integrated squared error
+            /// and has compact support on [-1, 1].
+            /// </remarks>
             public double Function(double x)
             {
                 if (Math.Abs(x) <= 1.0d)
@@ -443,6 +461,17 @@ public double Function(double x)
         /// </summary>
         private class GuassianKernel : IKernel
         {
+            /// <summary>
+            /// Evaluates the Gaussian (Normal) kernel function at the specified point.
+            /// </summary>
+            /// <param name="x">The point at which to evaluate the kernel.</param>
+            /// <returns>
+            /// The standard normal PDF value at x: (1/√(2π)) * exp(-x²/2).
+            /// </returns>
+            /// <remarks>
+            /// This is the default kernel for kernel density estimation. It has infinite support
+            /// and is infinitely differentiable.
+            /// </remarks>
             public double Function(double x)
             {
                 return Normal.StandardPDF(x);
@@ -455,6 +484,18 @@ public double Function(double x)
         private class TriangularKernel : IKernel
         {
             private Triangular _triangularDist = new Triangular(-1.0d, 0.0d, 1.0d);
+
+            /// <summary>
+            /// Evaluates the triangular kernel function at the specified point.
+            /// </summary>
+            /// <param name="x">The point at which to evaluate the kernel.</param>
+            /// <returns>
+            /// The triangular PDF value at x with minimum -1, mode 0, and maximum 1.
+            /// Returns (1 - |x|) for |x| ≤ 1, and 0 otherwise.
+            /// </returns>
+            /// <remarks>
+            /// The triangular kernel has compact support on [-1, 1] and is computationally efficient.
+            /// </remarks>
             public double Function(double x)
             {
                 return _triangularDist.PDF(x);
@@ -467,6 +508,19 @@ public double Function(double x)
         private class UniformKernel : IKernel
         {
             private Uniform _uniformDist = new Uniform(-1.0d, 1.0d);
+
+            /// <summary>
+            /// Evaluates the uniform kernel function at the specified point.
+            /// </summary>
+            /// <param name="x">The point at which to evaluate the kernel.</param>
+            /// <returns>
+            /// The uniform PDF value: 0.5 for |x| ≤ 1, and 0 otherwise.
+            /// </returns>
+            /// <remarks>
+            /// The uniform kernel has compact support on [-1, 1] and gives equal weight
+            /// to all points within the bandwidth. This is the simplest kernel but has
+            /// discontinuous derivatives.
+            /// </remarks>
             public double Function(double x)
             {
                 return _uniformDist.PDF(x);

Numerics/Distributions/Univariate/KernelDensity.cs

@@ -745,16 +745,14 @@ private double[] AccelerationConstants(IList<double> sampleData, IList<double> p
         }
 
         /// <summary>
-        /// Estimates the standard error for each probability.
+        /// Estimates the standard error for each probability using the parametric bootstrap.
         /// </summary>
-        /// <param name="sampleData">Sample of data.</param>
-        /// <param name="probabilities">List of non-exceedance probabilities.</param>
-        /// <param name="thetaHats">The list of best-estimate quantiles.</param>
+        ///<param name="parentDist">The parent distribution.</param>
+        ///<param name="probabilities">The list of probabilities where the standard error is calculated.</param>
+        ///<param name="replications">The number of bootstrap replications. Default = 300.</param>
+        ///<param name="seed">The PRNG seed. Default = 12345.</param>
         private double[] BootstrapStandardError(UnivariateDistributionBase parentDist, IList<double> probabilities, int replications = 300, int seed = 12345)
         {
-            //var N = sampleData.Count;
-            //var I2 = new double[probabilities.Count];
-            //var se = new double[probabilities.Count];
             int B = replications;
             var r = new MersenneTwister(seed);
             var seeds = r.NextIntegers(replications);