warning fixes.

Author: tikig21

Test_Numerics/Machine Learning/Supervised/Test_RandomForest.cs

@@ -89,7 +89,7 @@ public void Test_RandomForest_Iris()
             var accuracy = GoodnessOfFit.Accuracy(Y_test.Array, prediction.GetColumn(1));
 
             // Accuracy should be greater than or equal to 90%
-            Assert.IsTrue(accuracy >= 90);
+            Assert.IsGreaterThanOrEqualTo(90, accuracy);
 
         }
 
@@ -133,7 +133,7 @@ public void Test_RandomForest_Regression()
             var lmR2 = GoodnessOfFit.RSquared(Y_test.Array, lmPredict);
 
             // Random Forest is better
-            Assert.IsTrue(rfR2 > lmR2);
+            Assert.IsGreaterThan(lmR2, rfR2 );
 
         }
     }

Test_Numerics/Machine Learning/Supervised/Test_kNN.cs

@@ -162,7 +162,7 @@ public void Test_kNN_Regression()
             var lmR2 = GoodnessOfFit.RSquared(Y_test.Array, lmPredict);
 
             // kNN is better
-            Assert.IsTrue(knnR2 > lmR2);
+            Assert.IsGreaterThan(lmR2, knnR2 );
 
         }
 

Test_Numerics/Mathematics/Integration/Test_Vegas.cs

@@ -209,12 +209,12 @@ public void Test_PowerTransform_RareUpperTailEvent()
 
             // Analytical approximation: P(Sum > mean + 3σ) = P(Z > 3) ≈ 0.00135
             // We expect something in the ballpark of 1e-3 to 2e-3
-            Assert.IsTrue(failureProbability > 5E-4, $"Probability too small: {failureProbability:E6}");
-            Assert.IsTrue(failureProbability < 5E-3, $"Probability too large: {failureProbability:E6}");
+            Assert.IsGreaterThan(5E-4, failureProbability );
+            Assert.IsLessThan(5E-3, failureProbability );
 
             // Standard error should be reasonable (less than 50% of estimate)
             double relativeError = vegas.StandardError / Math.Abs(failureProbability);
-            Assert.IsTrue(relativeError < 0.5, $"Relative error too large: {relativeError:P1}");
+            Assert.IsLessThan(0.5, relativeError);
         }
 
         /// <summary>
@@ -255,14 +255,14 @@ public void Test_PowerTransform_VeryRareEvent()
             var failureProbability = vegas.Result;
 
             // Should be in ballpark of 1e-6 to 1e-5
-            Assert.IsTrue(failureProbability > 1E-7, $"Probability too small: {failureProbability:E2}");
-            Assert.IsTrue(failureProbability < 1E-4, $"Probability too large: {failureProbability:E2}");
+            Assert.IsGreaterThan(1E-7, failureProbability);
+            Assert.IsLessThan(1E-4, failureProbability);
 
             // For very rare events, relative error can be higher but should be finite
             double relativeError = vegas.StandardError / Math.Abs(failureProbability);
-            Assert.IsTrue(relativeError < 1.0, $"Relative error too large: {relativeError:P1}");
-            Assert.IsTrue(!double.IsNaN(failureProbability), "Result should not be NaN");
-            Assert.IsTrue(!double.IsInfinity(failureProbability), "Result should not be infinite");
+            Assert.IsLessThan(1.0, relativeError);
+            Assert.IsFalse(double.IsNaN(failureProbability), "Result should not be NaN");
+            Assert.IsFalse(double.IsInfinity(failureProbability), "Result should not be infinite");
         }
 
         /// <summary>
@@ -311,13 +311,13 @@ public void Test_PowerTransform_ProbabilityRange()
             vegas.Integrate();
 
             // Verify samples were generated
-            Assert.IsTrue(sampleCount > 0, "No samples generated");
+            Assert.IsGreaterThan( 0, sampleCount );
 
             // With γ=4, should see strong tail focus (many samples near 1.0)
-            Assert.IsTrue(maxObserved > 0.99, $"Max probability too low: {maxObserved}");
+            Assert.IsGreaterThan(0.99, maxObserved );
 
             // Should still have some diversity (not all at 1.0)
-            Assert.IsTrue(minObserved < 0.5, $"Min probability too high: {minObserved}");
+            Assert.IsLessThan(0.5, minObserved );
 
         }
 

Test_Numerics/Mathematics/Linear Algebra/Test_EigenValueDecomposition.cs

@@ -185,7 +185,7 @@ public void SymEig_3x3_RepeatedEigenvalues_AllTwos()
 
             // Max eigen residual
             var maxRes = MaxEigenResidual(A, V, w);
-            Assert.IsTrue(maxRes < 1e-12, $"Max eigen residual too large: {maxRes}");
+            Assert.IsLessThan(1e-12, maxRes);
         }
 
         /// <summary>
@@ -232,7 +232,7 @@ public void SymEig_8x8_TridiagonalToeplitz_KnownSpectrum()
 
             // Max eigen residual
             var maxRes = MaxEigenResidual(A, V, w);
-            Assert.IsTrue(maxRes < 1e-8, $"Max eigen residual too large: {maxRes}");
+            Assert.IsLessThan(1e-8, maxRes);
         }
 
         /// <summary>
@@ -268,7 +268,7 @@ public void SymEig_5x5_NearlyDiagonal_SmallCoupling()
 
             // Max eigen residual
             var maxRes = MaxEigenResidual(A, V, w);
-            Assert.IsTrue(maxRes < 1e-8, $"Max eigen residual too large: {maxRes}");
+            Assert.IsLessThan(1e-8, maxRes);
         }
 
         // ---------- Helpers ----------

Test_Numerics/Mathematics/Special Functions/Test_Gamma.cs

@@ -68,7 +68,7 @@ public void Test_Function()
             for (int i = 0; i < testValid.Length; i++)
             {
                 testResults[i] = Gamma.Function(testX[i]);
-                Assert.AreEqual(Math.Abs(testValid[i] - testResults[i]) / testValid[i] < 0.01, true);
+                Assert.IsLessThan(0.01, Math.Abs(testValid[i] - testResults[i]) / testValid[i]);
             }
         }
 
@@ -85,7 +85,7 @@ public void Test_Lanczos()
             for (int i = 0; i < testValid.Length; i++)
             {
                 testResults[i] = Gamma.Lanczos(testX[i]);
-                Assert.AreEqual(Math.Abs(testValid[i] - testResults[i]) / testValid[i] < 0.01, true);
+                Assert.IsLessThan(0.01, Math.Abs(testValid[i] - testResults[i]) / testValid[i]);
             }
         }
 
@@ -157,7 +157,7 @@ public void Test_Trigamma()
             for (int i = 0; i < testValid.Length; i++)
             {
                 testResults[i] = Gamma.Trigamma(testX[i]);
-                Assert.AreEqual(Math.Abs(testValid[i] - testResults[i]) / testValid[i] < 0.01, true);
+                Assert.IsLessThan(0.01, Math.Abs(testValid[i] - testResults[i]) / testValid[i]);
             }
         }
 
@@ -187,7 +187,7 @@ public void Test_LogGamma()
             for (int i = 0; i < testValid.Length; i++)
             {
                 testResults[i] = Gamma.LogGamma(testX[i]);
-                Assert.AreEqual(Math.Abs(testValid[i] - testResults[i]) / testValid[i] < 0.01, true);
+                Assert.IsLessThan(0.01, Math.Abs(testValid[i] - testResults[i]) / testValid[i]);
             }
         }
 
@@ -227,7 +227,7 @@ public void Test_Incomplete()
             for (int i = 0; i < testValid.Length; i++)
             {
                 testResults[i] = Gamma.Incomplete(testX[i], testA[i]);
-                Assert.AreEqual(Math.Abs(testValid[i] - testResults[i]) / testValid[i] < 0.01, true);
+                Assert.IsLessThan(0.01,Math.Abs(testValid[i] - testResults[i]) / testValid[i]);
             }
 
         }
@@ -460,7 +460,7 @@ public void Test_InverseUpperIncomplete()
                     double x = Gamma.UpperIncomplete(lambda, i);
                     double j = Gamma.InverseUpperIncomplete(lambda, x);
 
-                    Assert.IsTrue(Math.Abs(i - j) < 1e-2 * Math.Abs(j));
+                    Assert.IsLessThan(1e-2 * Math.Abs(j),Math.Abs(i - j) );
                 }
             }
         }

Test_Numerics/Mathematics/Special Functions/Test_SpecialFunctions.cs

@@ -207,8 +207,9 @@ public void Test_CombinationsNum()
             // Total number of possible combinations
             double possible = Math.Pow(2, 5) - 1;
 
+            var ccLen = cc.Length;
             // Length of cc should be the possible number of combinations * the number of elements in each combination (5)
-            Assert.AreEqual(possible * 5, cc.Length);
+            Assert.AreEqual(possible * 5, ccLen);
 
             // How many of subsets of combinations there should be
             // For example, there are 5 ways to have only one #1 in the array, with the other 4 elements being #0

Test_Numerics/Serialization/Test_JsonSerialization.cs

@@ -99,14 +99,14 @@ public void Test_UncertaintyAnalysisResults_ArraySerialization()
 
             // Assert
             Assert.IsNotNull(deserialized.ModeCurve);
-            Assert.AreEqual(original.ModeCurve.Length, deserialized.ModeCurve.Length);
+            Assert.HasCount(original.ModeCurve.Length, deserialized.ModeCurve);
             for (int i = 0; i < original.ModeCurve.Length; i++)
             {
                 Assert.AreEqual(original.ModeCurve[i], deserialized.ModeCurve[i], 1e-10);
             }
 
             Assert.IsNotNull(deserialized.MeanCurve);
-            Assert.AreEqual(original.MeanCurve.Length, deserialized.MeanCurve.Length);
+            Assert.HasCount(original.MeanCurve.Length, deserialized.MeanCurve);
             for (int i = 0; i < original.MeanCurve.Length; i++)
             {
                 Assert.AreEqual(original.MeanCurve[i], deserialized.MeanCurve[i], 1e-10);
@@ -161,9 +161,11 @@ public void Test_UncertaintyAnalysisResults_ParameterSetsSerialization()
             byte[] serialized = UncertaintyAnalysisResults.ToByteArray(original);
             var deserialized = UncertaintyAnalysisResults.FromByteArray(serialized);
 
+            var origLen = original.ParameterSets.Length;
+            var desLen = deserialized.ParameterSets.Length;
             // Assert
             Assert.IsNotNull(deserialized.ParameterSets);
-            Assert.AreEqual(original.ParameterSets.Length, deserialized.ParameterSets.Length);
+            Assert.AreEqual(origLen, desLen);
 
             for (int i = 0; i < original.ParameterSets.Length; i++)
             {
@@ -173,7 +175,7 @@ public void Test_UncertaintyAnalysisResults_ParameterSetsSerialization()
                 if (original.ParameterSets[i].Values != null)
                 {
                     Assert.IsNotNull(deserialized.ParameterSets[i].Values);
-                    Assert.AreEqual(original.ParameterSets[i].Values.Length, deserialized.ParameterSets[i].Values.Length);
+                    Assert.HasCount(original.ParameterSets[i].Values.Length, deserialized.ParameterSets[i].Values);
 
                     for (int j = 0; j < original.ParameterSets[i].Values.Length; j++)
                     {
@@ -246,11 +248,11 @@ public void Test_UncertaintyAnalysisResults_EmptyArrays()
             // Assert
             Assert.IsNotNull(deserialized);
             Assert.IsNotNull(deserialized.ParameterSets);
-            Assert.AreEqual(0, deserialized.ParameterSets.Length);
+            Assert.IsEmpty( deserialized.ParameterSets);
             Assert.IsNotNull(deserialized.ModeCurve);
-            Assert.AreEqual(0, deserialized.ModeCurve.Length);
+            Assert.IsEmpty(deserialized.ModeCurve);
             Assert.IsNotNull(deserialized.MeanCurve);
-            Assert.AreEqual(0, deserialized.MeanCurve.Length);
+            Assert.IsEmpty(deserialized.MeanCurve);
         }
 
         /// <summary>
@@ -293,10 +295,12 @@ public void Test_MCMCResults_BasicSerialization()
             byte[] serialized = MCMCResults.ToByteArray(original);
             var deserialized = MCMCResults.FromByteArray(serialized);
 
+            var origLen = original.AcceptanceRates.Length;
+            var desLen = deserialized.AcceptanceRates.Length;
             // Assert
             Assert.IsNotNull(deserialized);
             Assert.IsNotNull(deserialized.AcceptanceRates);
-            Assert.AreEqual(original.AcceptanceRates.Length, deserialized.AcceptanceRates.Length);
+            Assert.AreEqual(origLen, desLen);
 
             for (int i = 0; i < original.AcceptanceRates.Length; i++)
             {
@@ -323,14 +327,16 @@ public void Test_MCMCResults_MarkovChainsSerialization()
             byte[] serialized = MCMCResults.ToByteArray(original);
             var deserialized = MCMCResults.FromByteArray(serialized);
 
+            var origLen = original.MarkovChains.Length;
+            var desLen = deserialized.MarkovChains.Length;
             // Assert
             Assert.IsNotNull(deserialized.MarkovChains);
-            Assert.AreEqual(original.MarkovChains.Length, deserialized.MarkovChains.Length);
+            Assert.AreEqual(origLen, desLen);
 
             for (int i = 0; i < original.MarkovChains.Length; i++)
             {
                 Assert.IsNotNull(deserialized.MarkovChains[i]);
-                Assert.AreEqual(original.MarkovChains[i].Count, deserialized.MarkovChains[i].Count);
+                Assert.HasCount(original.MarkovChains[i].Count, deserialized.MarkovChains[i]);
 
                 for (int j = 0; j < original.MarkovChains[i].Count; j++)
                 {
@@ -368,7 +374,7 @@ public void Test_MCMCResults_OutputSerialization()
 
             // Assert
             Assert.IsNotNull(deserialized.Output);
-            Assert.AreEqual(original.Output.Count, deserialized.Output.Count);
+            Assert.HasCount(original.Output.Count, deserialized.Output);
 
             for (int i = 0; i < original.Output.Count; i++)
             {
@@ -423,7 +429,7 @@ public void Test_MCMCResults_MeanLogLikelihoodSerialization()
 
             // Assert
             Assert.IsNotNull(deserialized.MeanLogLikelihood);
-            Assert.AreEqual(original.MeanLogLikelihood.Count, deserialized.MeanLogLikelihood.Count);
+            Assert.HasCount(original.MeanLogLikelihood.Count, deserialized.MeanLogLikelihood);
 
             for (int i = 0; i < original.MeanLogLikelihood.Count; i++)
             {
@@ -461,9 +467,9 @@ public void Test_MCMCResults_EmptyChains()
             // Assert
             Assert.IsNotNull(deserialized);
             Assert.IsNotNull(deserialized.MarkovChains);
-            Assert.AreEqual(2, deserialized.MarkovChains.Length);
-            Assert.AreEqual(0, deserialized.MarkovChains[0].Count);
-            Assert.AreEqual(0, deserialized.MarkovChains[1].Count);
+            Assert.HasCount(2, deserialized.MarkovChains);
+            Assert.HasCount(0, deserialized.MarkovChains[0]);
+            Assert.HasCount(0, deserialized.MarkovChains[1]);
         }
 
         /// <summary>
@@ -486,9 +492,11 @@ public void Test_MCMCResults_LargeDataSet()
             byte[] serialized = MCMCResults.ToByteArray(original);
             var deserialized = MCMCResults.FromByteArray(serialized);
 
+            var origLen = original.MarkovChains.Length;
+            var deserializedLen = deserialized.MarkovChains.Length;
             // Assert
             Assert.IsNotNull(deserialized);
-            Assert.AreEqual(original.MarkovChains.Length, deserialized.MarkovChains.Length);
+            Assert.AreEqual(origLen, deserializedLen);
 
             // Verify first and last elements to ensure proper serialization
             var firstOriginal = original.MarkovChains[0][0];
@@ -531,15 +539,15 @@ public void Test_JsonSerializerOptions_Configuration()
 
             // Assert
             // Verify that WriteIndented is false (no formatting whitespace)
-            Assert.IsFalse(jsonString.Contains("\n"));
-            Assert.IsFalse(jsonString.Contains("  ")); // No indentation
+            Assert.DoesNotContain(jsonString,("\n"));
+            Assert.DoesNotContain(jsonString, ("  ")); // No indentation
 
             // Verify that null values are not included (DefaultIgnoreCondition)
-            Assert.IsFalse(jsonString.Contains("\"ParentDistribution\":null"));
+            Assert.DoesNotContain(jsonString,  ("\"ParentDistribution\":null"));
 
             // Verify that fields are included (IncludeFields = true)
-            Assert.IsTrue(jsonString.Contains("\"AIC\":"));
-            Assert.IsTrue(jsonString.Contains("\"BIC\":"));
+            Assert.DoesNotContain(jsonString, ("\"AIC\":"));
+            Assert.DoesNotContain(jsonString, ("\"BIC\":"));
         }
 
         #endregion

Test_Numerics/Utilities/Test_ExtensionMethods.cs

@@ -84,7 +84,7 @@ public void Test_NextIntegers()
         {
             var random = new Random();
             var result = random.NextIntegers(5);
-            Assert.AreEqual(5, result.Length);
+            Assert.HasCount(5, result);
         }
 
         /// <summary>
@@ -95,7 +95,7 @@ public void Test_NextIntegersMinMax()
         {
             var random = new Random();
             var result = random.NextIntegers(0, 10, 5);
-            Assert.AreEqual(5, result.Length);
+            Assert.HasCount(5, result);
             for (int i = 0; i < result.Length; i++)
                 Assert.IsTrue(result[i] >= 0 && result[i] < 10);
         }
@@ -134,7 +134,7 @@ public void Test_NextDoubles()
         {
             var random = new Random();
             var result = random.NextDoubles(5);
-            Assert.AreEqual(5, result.Length);
+            Assert.HasCount(5, result);
             for (int i = 0; i < result.Length; i++)
                 Assert.IsTrue(result[i] >= 0 && result[i] < 1);
         }
@@ -275,7 +275,7 @@ public void Test_Random_Subset()
             var array = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
             var result = array.RandomSubset(5);          
             CollectionAssert.IsSubsetOf(result, array);
-            Assert.AreEqual(5, result.Length);
+            Assert.HasCount(5, result);
         }
 
         /// <summary>
@@ -420,7 +420,7 @@ public void Test_Vector_Random_Subset()
             var vector = new Vector(new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 });
             var result = vector.RandomSubset(5).Array;
             CollectionAssert.IsSubsetOf(result, vector.Array);
-            Assert.AreEqual(5, result.Length);
+            Assert.HasCount(5, result);
         }
 
         /// <summary>