feat: complete first MITC4 FEAST eigen implementation validation

tests/reference/reference_tolerance_policy.cpp

@@ -19,10 +19,9 @@ bool IsFiniteFamily(const ReferenceToleranceFamily& family) {
                      });
 }
 
-}
-
-ReferenceToleranceEvaluation ReferenceTolerancePolicy::Evaluate(
-    const std::vector<ReferenceToleranceFamily>& families) {
+ReferenceToleranceEvaluation EvaluateFamilies(
+    const std::vector<ReferenceToleranceFamily>& families,
+    const double relative_rms_tolerance) {
   ReferenceToleranceEvaluation evaluation{true, {}, true, {}};
   evaluation.families.reserve(families.size());
 
@@ -41,7 +40,8 @@ ReferenceToleranceEvaluation ReferenceTolerancePolicy::Evaluate(
       decision.reference_scale =
           (std::max)(decision.reference_scale, std::abs(row.reference_value));
     }
-    decision.near_zero_band = kNearZeroRatio * decision.reference_scale;
+    decision.near_zero_band =
+        ReferenceTolerancePolicy::kNearZeroRatio * decision.reference_scale;
 
     double error_norm = 0.0;
     for (std::size_t index = 0U; index < family.rows.size(); ++index) {
@@ -74,12 +74,14 @@ ReferenceToleranceEvaluation ReferenceTolerancePolicy::Evaluate(
         row_decision.passed = absolute_error <= row_decision.threshold;
       } else {
         row_decision.threshold =
-            kRelativeTolerance * std::abs(row.reference_value);
+            ReferenceTolerancePolicy::kRelativeTolerance *
+            std::abs(row.reference_value);
         row_decision.relative_error =
             absolute_error / std::abs(row.reference_value);
         row_decision.relative_error_applicable = true;
         row_decision.branch = ReferenceToleranceBranch::kRelative;
-        row_decision.passed = row_decision.relative_error <= kRelativeTolerance;
+        row_decision.passed = row_decision.relative_error <=
+                              ReferenceTolerancePolicy::kRelativeTolerance;
       }
       decision.rows.push_back(row_decision);
     }
@@ -100,7 +102,7 @@ ReferenceToleranceEvaluation ReferenceTolerancePolicy::Evaluate(
       if (!std::isfinite(decision.relative_rms)) {
         return {false, "nonfinite-comparison-value", false, {}};
       }
-      decision.rms_passed = decision.relative_rms <= kRelativeRmsTolerance;
+      decision.rms_passed = decision.relative_rms <= relative_rms_tolerance;
     }
     decision.passed = rows_passed && decision.rms_passed;
     if (decision.blocking && !decision.passed) {
@@ -112,4 +114,25 @@ ReferenceToleranceEvaluation ReferenceTolerancePolicy::Evaluate(
   return evaluation;
 }
 
+}  // namespace
+
+ReferenceToleranceEvaluation ReferenceTolerancePolicy::Evaluate(
+    const std::vector<ReferenceToleranceFamily>& families) {
+  return EvaluateFamilies(families, kRelativeRmsTolerance);
+}
+
+ReferenceToleranceEvaluation
+ReferenceTolerancePolicy::EvaluateMitc4EigenFirstImplementation(
+    const std::vector<ReferenceToleranceFamily>& families) {
+  if (families.empty() ||
+      !std::all_of(families.begin(), families.end(), [](const auto& family) {
+        return family.blocking && family.rows.size() == 1U &&
+               family.components.size() == 1U &&
+               family.components.front() == "Value";
+      })) {
+    return {false, "invalid-eigen-tolerance-family", false, {}};
+  }
+  return EvaluateFamilies(families, kRelativeTolerance);
+}
+
 }