fix(stats): break EnsureFullStatsComputed recursion in errorstats/modelstats/predictionstats

Same bug class as the earlier BasicStats fix: the Calculate* method was
assigning to properties AND reading them back during its own body, but
the property getters call EnsureFullStatsComputed — which is still
running the Calculate* method. The _fullStatsComputed flag only flips
after Calculate* returns, so any intra-method property read re-enters
Calculate* unbounded. The test host crashes with StackOverflowException
before the test framework can report anything except "host process
exited unexpectedly."

Specific re-entry points the previous code had:

  * ErrorStats.CalculateErrorStats
    - RMSE = _numOps.Sqrt(MSE)              ← re-enters via MSE getter
    - AIC/BIC/AICAlt pass RSS                ← re-enters via RSS getter

  * ModelStats.CalculateModelStats
    - VIFList = ... CalculateVIF(CorrelationMatrix, ...) ← CorrelationMatrix
    - Mahalanobis block reads CovarianceMatrix thrice  ← CovarianceMatrix

  * PredictionStats.CalculatePredictionStats
    - AdjustedR2 = ... CalculateAdjustedR2(R2, ...)         ← R2
    - PredictionIntervalCoverage = ... (PredictionInterval.Lower,
      PredictionInterval.Upper)                             ← PredictionInterval
    - ConfidenceInterval/CredibleInterval read BestDistributionFit
      .DistributionType                                     ← BestDistributionFit

All three methods are rewritten to compute every intermediate into a
local variable first; properties are only assigned once every dependency
is a local. No property reads happen inside Calculate*, so the lazy
getter never re-enters.

Observed failure path (Classification CI shard, PR #1156 run):
  AdaBoostClassifierTests.Predict_ShouldBeDeterministic trains the
  model, which computes ErrorStats, which stack-overflows the host.
  Other crashed tests in the same shard:
    - ExtraTreesClassifierTests.Clone_ShouldProduceIdenticalPredictions
    - CategoricalNaiveBayesTests.Builder_AccuracyShouldBeatChance
    - OneVsRestClassifierTests.Builder_AccuracyShouldBeatChance
  All 4 pass locally after this fix.

Unblocks the host_crash jobs on PR #1154 triage:
  - ModelFamily - Classification
  - ModelFamily - Clustering/GP
  - ModelFamily - Regression
  - ModelFamily - TimeSeries/Activation/Loss
  - Unit - 04 Feature/Fit/Fitness/Genetics
  - AiDotNet.Serving.Tests

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ooples

src/Statistics/ErrorStats.cs

@@ -513,50 +513,83 @@ public static ErrorStats<T> Empty()
     /// </remarks>
     private void CalculateErrorStats(Vector<T> actual, Vector<T> predicted, int numberOfParameters, PredictionType predictionType = PredictionType.Regression)
     {
+        // All intermediate values are held in locals and only assigned to the
+        // observable properties at the very end. Earlier code called
+        //   RMSE = _numOps.Sqrt(MSE);
+        //   AIC = StatisticsHelper.CalculateAIC(n, numberOfParameters, RSS);
+        // which read MSE/RSS through their property getters. Those getters call
+        // EnsureFullStatsComputed, which is still running CalculateErrorStats —
+        // so the property read re-enters CalculateErrorStats and recurses
+        // without bound. The test host crashes with StackOverflowException
+        // (Classification / Clustering / Regression / TimeSeries / Serving
+        // host-crashes on PR #1154 and master).
         int n = actual.Length;
 
-        // Calculate basic error metrics
-        MAE = StatisticsHelper<T>.CalculateMeanAbsoluteError(actual, predicted);
-        RSS = StatisticsHelper<T>.CalculateResidualSumOfSquares(actual, predicted);
-        MSE = StatisticsHelper<T>.CalculateMeanSquaredError(actual, predicted);
-        RMSE = _numOps.Sqrt(MSE);
-        MAPE = StatisticsHelper<T>.CalculateMeanAbsolutePercentageError(actual, predicted);
-        MedianAbsoluteError = StatisticsHelper<T>.CalculateMedianAbsoluteError(actual, predicted);
-        MaxError = StatisticsHelper<T>.CalculateMaxError(actual, predicted);
+        T mae = StatisticsHelper<T>.CalculateMeanAbsoluteError(actual, predicted);
+        T rss = StatisticsHelper<T>.CalculateResidualSumOfSquares(actual, predicted);
+        T mse = StatisticsHelper<T>.CalculateMeanSquaredError(actual, predicted);
+        T rmse = _numOps.Sqrt(mse);
+        T mape = StatisticsHelper<T>.CalculateMeanAbsolutePercentageError(actual, predicted);
+        T medAbs = StatisticsHelper<T>.CalculateMedianAbsoluteError(actual, predicted);
+        T maxErr = StatisticsHelper<T>.CalculateMaxError(actual, predicted);
+        T aucPR, aucROC;
         if (predictionType == PredictionType.BinaryClassification)
         {
-            AUCPR = StatisticsHelper<T>.CalculatePrecisionRecallAUC(actual, predicted);
-            AUCROC = StatisticsHelper<T>.CalculateROCAUC(actual, predicted);
+            aucPR = StatisticsHelper<T>.CalculatePrecisionRecallAUC(actual, predicted);
+            aucROC = StatisticsHelper<T>.CalculateROCAUC(actual, predicted);
         }
         else
         {
-            AUCPR = _numOps.Zero;
-            AUCROC = _numOps.Zero;
+            aucPR = _numOps.Zero;
+            aucROC = _numOps.Zero;
         }
-        SMAPE = StatisticsHelper<T>.CalculateSymmetricMeanAbsolutePercentageError(actual, predicted);
-        MeanSquaredLogError = StatisticsHelper<T>.CalculateMeanSquaredLogError(actual, predicted);
-        CRPS = StatisticsHelper<T>.CalculateCRPS(actual, predicted);
-
-        // Calculate standard errors
-        SampleStandardError = StatisticsHelper<T>.CalculateSampleStandardError(actual, predicted, numberOfParameters);
-        PopulationStandardError = StatisticsHelper<T>.CalculatePopulationStandardError(actual, predicted);
-
-        // Calculate bias and autocorrelation metrics
-        MeanBiasError = StatisticsHelper<T>.CalculateMeanBiasError(actual, predicted);
-        TheilUStatistic = StatisticsHelper<T>.CalculateTheilUStatistic(actual, predicted);
-        DurbinWatsonStatistic = StatisticsHelper<T>.CalculateDurbinWatsonStatistic(actual, predicted);
-
-        // Calculate information criteria
-        AIC = StatisticsHelper<T>.CalculateAIC(n, numberOfParameters, RSS);
-        BIC = StatisticsHelper<T>.CalculateBIC(n, numberOfParameters, RSS);
-        AICAlt = StatisticsHelper<T>.CalculateAICAlternative(n, numberOfParameters, RSS);
-
-        // Calculate classification metrics
-        Accuracy = StatisticsHelper<T>.CalculateAccuracy(actual, predicted, predictionType);
-        (Precision, Recall, F1Score) = StatisticsHelper<T>.CalculatePrecisionRecallF1(actual, predicted, predictionType);
-
-        // Populate error list
-        ErrorList = new List<T>(StatisticsHelper<T>.CalculateResiduals(actual, predicted));
+        T smape = StatisticsHelper<T>.CalculateSymmetricMeanAbsolutePercentageError(actual, predicted);
+        T msle = StatisticsHelper<T>.CalculateMeanSquaredLogError(actual, predicted);
+        T crps = StatisticsHelper<T>.CalculateCRPS(actual, predicted);
+
+        T sampleStd = StatisticsHelper<T>.CalculateSampleStandardError(actual, predicted, numberOfParameters);
+        T popStd = StatisticsHelper<T>.CalculatePopulationStandardError(actual, predicted);
+
+        T bias = StatisticsHelper<T>.CalculateMeanBiasError(actual, predicted);
+        T theil = StatisticsHelper<T>.CalculateTheilUStatistic(actual, predicted);
+        T dw = StatisticsHelper<T>.CalculateDurbinWatsonStatistic(actual, predicted);
+
+        T aic = StatisticsHelper<T>.CalculateAIC(n, numberOfParameters, rss);
+        T bic = StatisticsHelper<T>.CalculateBIC(n, numberOfParameters, rss);
+        T aicAlt = StatisticsHelper<T>.CalculateAICAlternative(n, numberOfParameters, rss);
+
+        T accuracy = StatisticsHelper<T>.CalculateAccuracy(actual, predicted, predictionType);
+        var (precision, recall, f1) = StatisticsHelper<T>.CalculatePrecisionRecallF1(actual, predicted, predictionType);
+
+        var residuals = new List<T>(StatisticsHelper<T>.CalculateResiduals(actual, predicted));
+
+        // Assign to the observable properties only after every dependency is a
+        // local — no re-entry possible now.
+        MAE = mae;
+        RSS = rss;
+        MSE = mse;
+        RMSE = rmse;
+        MAPE = mape;
+        MedianAbsoluteError = medAbs;
+        MaxError = maxErr;
+        AUCPR = aucPR;
+        AUCROC = aucROC;
+        SMAPE = smape;
+        MeanSquaredLogError = msle;
+        CRPS = crps;
+        SampleStandardError = sampleStd;
+        PopulationStandardError = popStd;
+        MeanBiasError = bias;
+        TheilUStatistic = theil;
+        DurbinWatsonStatistic = dw;
+        AIC = aic;
+        BIC = bic;
+        AICAlt = aicAlt;
+        Accuracy = accuracy;
+        Precision = precision;
+        Recall = recall;
+        F1Score = f1;
+        ErrorList = residuals;
     }
 
     /// <summary>

src/Statistics/ModelStats.cs

@@ -552,14 +552,16 @@ public static ModelStats<T, TInput, TOutput> Empty()
     /// </remarks>
     private void CalculateModelStats(ModelStatsInputs<T, TInput, TOutput> inputs)
     {
-        // Convert input matrix to Matrix<T> for statistical calculations
+        // All intermediate values held in locals until the end. Previous code
+        // read CorrelationMatrix and CovarianceMatrix through their property
+        // getters during computation; those getters call
+        // EnsureFullStatsComputed, which re-enters this method — unbounded
+        // recursion + StackOverflowException. Same bug class as BasicStats /
+        // ErrorStats / PredictionStats.
         Matrix<T> matrix = ConversionsHelper.ConvertToMatrix<T, TInput>(inputs.XMatrix);
-
-        // Convert actual and predicted values to Vector<T> for statistical calculations
         Vector<T> actual = ConversionsHelper.ConvertToVector<T, TOutput>(inputs.Actual);
         Vector<T> predicted = ConversionsHelper.ConvertToVector<T, TOutput>(inputs.Predicted);
 
-        // Convert coefficients if available
         Vector<T> coefficients = Vector<T>.Empty();
         if (inputs.Coefficients != null)
         {
@@ -568,64 +570,89 @@ private void CalculateModelStats(ModelStatsInputs<T, TInput, TOutput> inputs)
 
         var featureCount = inputs.FeatureCount;
 
-        // Calculate all statistical metrics using the converted data types
-        CorrelationMatrix = StatisticsHelper<T>.CalculateCorrelationMatrix(matrix, _options);
-        CovarianceMatrix = StatisticsHelper<T>.CalculateCovarianceMatrix(matrix);
-        VIFList = StatisticsHelper<T>.CalculateVIF(CorrelationMatrix, _options);
-        ConditionNumber = StatisticsHelper<T>.CalculateConditionNumber(matrix, _options);
-        LogPointwisePredictiveDensity = StatisticsHelper<T>.CalculateLogPointwisePredictiveDensity(actual, predicted);
+        var correlationMatrix = StatisticsHelper<T>.CalculateCorrelationMatrix(matrix, _options);
+        var covarianceMatrix = StatisticsHelper<T>.CalculateCovarianceMatrix(matrix);
+        var vifList = StatisticsHelper<T>.CalculateVIF(correlationMatrix, _options);
+        T conditionNumber = StatisticsHelper<T>.CalculateConditionNumber(matrix, _options);
+        T logPpd = StatisticsHelper<T>.CalculateLogPointwisePredictiveDensity(actual, predicted);
 
+        List<T>? looPd = null;
         if (inputs.FitFunction != null)
         {
-            // Convert the fit function to work with Matrix<T> and Vector<T>
             var convertedFitFunction = ConversionsHelper.ConvertFitFunction<T, TInput, TOutput>(inputs.FitFunction);
-
-            // Create a wrapper function that matches the expected signature
             Vector<T> wrappedFitFunction(Matrix<T> m, Vector<T> v) => convertedFitFunction(m);
-            LeaveOneOutPredictiveDensities = StatisticsHelper<T>.CalculateLeaveOneOutPredictiveDensities(matrix, actual, wrappedFitFunction);
+            looPd = StatisticsHelper<T>.CalculateLeaveOneOutPredictiveDensities(matrix, actual, wrappedFitFunction);
         }
 
-        ObservedTestStatistic = StatisticsHelper<T>.CalculateObservedTestStatistic(actual, predicted);
-        PosteriorPredictiveSamples = StatisticsHelper<T>.CalculatePosteriorPredictiveSamples(actual, predicted, featureCount);
-        MarginalLikelihood = StatisticsHelper<T>.CalculateMarginalLikelihood(actual, predicted, featureCount);
-        ReferenceModelMarginalLikelihood = StatisticsHelper<T>.CalculateReferenceModelMarginalLikelihood(actual);
-        LogLikelihood = StatisticsHelper<T>.CalculateLogLikelihood(actual, predicted);
-        EffectiveNumberOfParameters = StatisticsHelper<T>.CalculateEffectiveNumberOfParameters(matrix, coefficients);
-        MutualInformation = StatisticsHelper<T>.CalculateMutualInformation(actual, predicted);
-        NormalizedMutualInformation = StatisticsHelper<T>.CalculateNormalizedMutualInformation(actual, predicted);
-        VariationOfInformation = StatisticsHelper<T>.CalculateVariationOfInformation(actual, predicted);
-        SilhouetteScore = StatisticsHelper<T>.CalculateSilhouetteScore(matrix, predicted);
-        CalinskiHarabaszIndex = StatisticsHelper<T>.CalculateCalinskiHarabaszIndex(matrix, predicted);
-        DaviesBouldinIndex = StatisticsHelper<T>.CalculateDaviesBouldinIndex(matrix, predicted);
-        MeanAveragePrecision = StatisticsHelper<T>.CalculateMeanAveragePrecision(actual, predicted, _options.MapTopK);
-        NormalizedDiscountedCumulativeGain = StatisticsHelper<T>.CalculateNDCG(actual, predicted, _options.NdcgTopK);
-        MeanReciprocalRank = StatisticsHelper<T>.CalculateMeanReciprocalRank(actual, predicted);
-
-        // Calculate residuals and time series metrics
+        T observedTest = StatisticsHelper<T>.CalculateObservedTestStatistic(actual, predicted);
+        var posteriorSamples = StatisticsHelper<T>.CalculatePosteriorPredictiveSamples(actual, predicted, featureCount);
+        T marginalLik = StatisticsHelper<T>.CalculateMarginalLikelihood(actual, predicted, featureCount);
+        T refModelML = StatisticsHelper<T>.CalculateReferenceModelMarginalLikelihood(actual);
+        T logLik = StatisticsHelper<T>.CalculateLogLikelihood(actual, predicted);
+        T effParams = StatisticsHelper<T>.CalculateEffectiveNumberOfParameters(matrix, coefficients);
+        T mi = StatisticsHelper<T>.CalculateMutualInformation(actual, predicted);
+        T nmi = StatisticsHelper<T>.CalculateNormalizedMutualInformation(actual, predicted);
+        T voi = StatisticsHelper<T>.CalculateVariationOfInformation(actual, predicted);
+        T silhouette = StatisticsHelper<T>.CalculateSilhouetteScore(matrix, predicted);
+        T ch = StatisticsHelper<T>.CalculateCalinskiHarabaszIndex(matrix, predicted);
+        T db = StatisticsHelper<T>.CalculateDaviesBouldinIndex(matrix, predicted);
+        T mAP = StatisticsHelper<T>.CalculateMeanAveragePrecision(actual, predicted, _options.MapTopK);
+        T ndcg = StatisticsHelper<T>.CalculateNDCG(actual, predicted, _options.NdcgTopK);
+        T mrr = StatisticsHelper<T>.CalculateMeanReciprocalRank(actual, predicted);
+
         var residuals = StatisticsHelper<T>.CalculateResiduals(actual, predicted);
-        AutoCorrelationFunction = StatisticsHelper<T>.CalculateAutoCorrelationFunction(residuals, _options.AcfMaxLag);
-        PartialAutoCorrelationFunction = StatisticsHelper<T>.CalculatePartialAutoCorrelationFunction(residuals, _options.PacfMaxLag);
-
-        // Calculate distance metrics
-        EuclideanDistance = StatisticsHelper<T>.CalculateDistance(actual, predicted, DistanceMetricType.Euclidean);
-        ManhattanDistance = StatisticsHelper<T>.CalculateDistance(actual, predicted, DistanceMetricType.Manhattan);
-        CosineSimilarity = StatisticsHelper<T>.CalculateDistance(actual, predicted, DistanceMetricType.Cosine);
-        JaccardSimilarity = StatisticsHelper<T>.CalculateDistance(actual, predicted, DistanceMetricType.Jaccard);
-        HammingDistance = StatisticsHelper<T>.CalculateDistance(actual, predicted, DistanceMetricType.Hamming);
-
-        // Mahalanobis distance requires vector dimensions to match covariance matrix dimensions
-        // Skip calculation if dimensions don't match (covariance is feature x feature, not sample x sample)
+        var acf = StatisticsHelper<T>.CalculateAutoCorrelationFunction(residuals, _options.AcfMaxLag);
+        var pacf = StatisticsHelper<T>.CalculatePartialAutoCorrelationFunction(residuals, _options.PacfMaxLag);
+
+        T euclidean = StatisticsHelper<T>.CalculateDistance(actual, predicted, DistanceMetricType.Euclidean);
+        T manhattan = StatisticsHelper<T>.CalculateDistance(actual, predicted, DistanceMetricType.Manhattan);
+        T cosine = StatisticsHelper<T>.CalculateDistance(actual, predicted, DistanceMetricType.Cosine);
+        T jaccard = StatisticsHelper<T>.CalculateDistance(actual, predicted, DistanceMetricType.Jaccard);
+        T hamming = StatisticsHelper<T>.CalculateDistance(actual, predicted, DistanceMetricType.Hamming);
+
+        T mahalanobis = _numOps.Zero;
         try
         {
-            if (CovarianceMatrix.Rows == actual.Length && CovarianceMatrix.Columns == actual.Length)
+            if (covarianceMatrix.Rows == actual.Length && covarianceMatrix.Columns == actual.Length)
             {
-                MahalanobisDistance = StatisticsHelper<T>.CalculateDistance(actual, predicted, DistanceMetricType.Mahalanobis, CovarianceMatrix);
+                mahalanobis = StatisticsHelper<T>.CalculateDistance(actual, predicted, DistanceMetricType.Mahalanobis, covarianceMatrix);
             }
         }
         catch (ArgumentException)
         {
-            // Silently skip Mahalanobis distance calculation when dimensions don't match
+            // Silently skip Mahalanobis distance calculation when dimensions don't match.
         }
+
+        // Assign properties once every dependency is a local — no re-entry.
+        CorrelationMatrix = correlationMatrix;
+        CovarianceMatrix = covarianceMatrix;
+        VIFList = vifList;
+        ConditionNumber = conditionNumber;
+        LogPointwisePredictiveDensity = logPpd;
+        if (looPd != null) LeaveOneOutPredictiveDensities = looPd;
+        ObservedTestStatistic = observedTest;
+        PosteriorPredictiveSamples = posteriorSamples;
+        MarginalLikelihood = marginalLik;
+        ReferenceModelMarginalLikelihood = refModelML;
+        LogLikelihood = logLik;
+        EffectiveNumberOfParameters = effParams;
+        MutualInformation = mi;
+        NormalizedMutualInformation = nmi;
+        VariationOfInformation = voi;
+        SilhouetteScore = silhouette;
+        CalinskiHarabaszIndex = ch;
+        DaviesBouldinIndex = db;
+        MeanAveragePrecision = mAP;
+        NormalizedDiscountedCumulativeGain = ndcg;
+        MeanReciprocalRank = mrr;
+        AutoCorrelationFunction = acf;
+        PartialAutoCorrelationFunction = pacf;
+        EuclideanDistance = euclidean;
+        ManhattanDistance = manhattan;
+        CosineSimilarity = cosine;
+        JaccardSimilarity = jaccard;
+        HammingDistance = hamming;
+        MahalanobisDistance = mahalanobis;
     }
 
     /// <summary>