Integrate Refactor solver sources and dual MSVC CMake builds

src/fesa/analysis/hht_reduced_operators.cpp

@@ -10,13 +10,18 @@
 #include <string>
 #include <utility>
 
+#include "fesa/core/source_identity.h"
 #include "fesa/solvers/linear/tangent_solver.h"
 #include "math/dense_blas_internal.h"
 #include "math/high_low_arithmetic.h"
+#include "math/finite_values.h"
+#include "math/compensated_sum.h"
 
 namespace fesa::hht_reduced_internal {
 namespace {
 
+using RateSum = math_internal::CompensatedSum;
+
 Status Failure(const std::string& message,
                const std::string& code = "dynamic-invalid-state") {
   return Status::Failure(FailureCategory::kSolver,
@@ -25,27 +30,9 @@ Status Failure(const std::string& message,
 }
 
 bool Finite(const Vector& values) {
-  for (std::size_t i = 0U; i < values.Size(); ++i)
-    if (!std::isfinite(values[i])) return false;
-  return true;
+  return math_internal::IsFinite(values);
 }
 
-class RateSum {
- public:
-  void Add(const double term) {
-    const double next = sum_ + term;
-    correction_ += std::abs(sum_) >= std::abs(term)
-                       ? (sum_ - next) + term
-                       : (term - next) + sum_;
-    sum_ = next;
-  }
-  double Value() const { return sum_ + correction_; }
-
- private:
-  double sum_ = 0.0;
-  double correction_ = 0.0;
-};
-
 bool ExactlyEqual(const Vector& left, const Vector& right) {
   if (left.Size() != right.Size()) return false;
   for (std::size_t i = 0U; i < left.Size(); ++i)
@@ -65,13 +52,6 @@ bool SameBits(const double left, const double right) {
   return std::memcmp(&left, &right, sizeof(double)) == 0;
 }
 
-/// @brief Compares semantic and original source identity without object keys.
-bool SameSource(const SourceEntityId& left, const SourceEntityId& right) {
-  return left.instance_name == right.instance_name &&
-         left.source_label == right.source_label &&
-         left.source_label_text == right.source_label_text;
-}
-
 /// @brief Finds only the current complete directional response, otherwise miss.
 const hht_internal::DirectionalShellConstraintData* MatchingConstraints(
     const Domain& domain, const hht_internal::RuntimeShell& shell,
@@ -98,7 +78,7 @@ const hht_internal::DirectionalShellConstraintData* MatchingConstraints(
           hht_internal::ReadTrialEvaluationContext()))
     return nullptr;
   const auto configuration =
-      nonlinear_mitc4_internal::ConfigurationSnapshot::Read(shell.internal);
+      nonlinear_mitc4_internal::ConfigurationSnapshot::Read(*shell.internal_kernel);
   if (record.configuration.source.file != configuration.source.file ||
       record.configuration.source.line != configuration.source.line ||
       record.configuration.identity != configuration.identity)
@@ -116,7 +96,7 @@ const hht_internal::DirectionalShellConstraintData* MatchingConstraints(
   for (std::size_t node = 0U; node < 4U; ++node) {
     const auto global_node = shell.scatter[6U * node] / 6U;
     if (global_node >= domain.Nodes().size() ||
-        !SameSource(record.node_source_ids[node],
+        !SourceIdentityEquals(record.node_source_ids[node],
                     domain.Nodes()[global_node].source_id))
       return nullptr;
   }
@@ -534,7 +514,7 @@ Result<ConstraintOperators> EvaluateConstraintOperators(
     std::optional<NonlinearMitc4InternalEquilibrium> fresh;
     if (saved == nullptr) {
       auto internal =
-          EvaluateInternalResidualAndTangent(shell.internal, Trial(q), &v);
+          shell.internal->EvaluateTrial(Trial(q), &v);
       if (!internal.HasValue())
         return Result<ConstraintOperators>::Failure(internal.GetStatus());
       fresh = std::move(internal.Value());
@@ -572,7 +552,7 @@ Result<ConstraintOperators> EvaluateConstraintOperators(
       if (external_done[global_node]) continue;
       external_done[global_node] = true;
       const auto first = 6U * global_node + 3U;
-      const auto external = shell.internal.EvaluateExternalDrillingConstraint(
+      const auto external = shell.internal->EvaluateExternalDrillingConstraint(
           local_node, Vector3{q[6U * local_node + 3U],
                               q[6U * local_node + 4U],
                               q[6U * local_node + 5U]},
@@ -587,7 +567,7 @@ Result<ConstraintOperators> EvaluateConstraintOperators(
                   force_acceleration[first + 2U]});
       if (!external.HasValue())
         return Result<ConstraintOperators>::Failure(external.GetStatus());
-      const auto rate_term = shell.internal.EvaluateExternalDrillingConstraint(
+      const auto rate_term = shell.internal->EvaluateExternalDrillingConstraint(
           local_node, Vector3{q[6U * local_node + 3U],
                               q[6U * local_node + 4U],
                               q[6U * local_node + 5U]},
@@ -596,7 +576,7 @@ Result<ConstraintOperators> EvaluateConstraintOperators(
       if (!rate_term.HasValue())
         return Result<ConstraintOperators>::Failure(rate_term.GetStatus());
       const auto acceleration_term =
-          shell.internal.EvaluateExternalDrillingConstraint(
+          shell.internal->EvaluateExternalDrillingConstraint(
               local_node, Vector3{q[6U * local_node + 3U],
                                   q[6U * local_node + 4U],
                                   q[6U * local_node + 5U]},
@@ -1321,21 +1301,10 @@ Result<double> CheckGraphRegularity(
   if (!sparse.HasValue()) return Result<double>::Failure(sparse.GetStatus());
   Status status = solver.FactorizeFresh(sparse.Value());
   if (!status.IsOk()) return Result<double>::Failure(status);
-  Vector inverse_sums{size};
-  for (std::size_t column = 0U; column < size; ++column) {
-    Vector rhs{size};
-    rhs[column] = 1.0;
-    Vector solution{size};
-    status = solver.SolveCorrection(rhs, solution);
-    if (!status.IsOk()) return Result<double>::Failure(status);
-    status = hht_internal::CheckLinearSolve(sparse.Value(), rhs, solution);
-    if (!status.IsOk()) return Result<double>::Failure(status);
-    for (std::size_t row = 0U; row < size; ++row)
-      inverse_sums[row] += std::abs(solution[row]);
-  }
   double inverse_norm = 0.0;
-  for (std::size_t row = 0U; row < size; ++row)
-    inverse_norm = std::max(inverse_norm, inverse_sums[row]);
+  status = hht_internal::AccumulateCheckedCanonicalNorm(
+      sparse.Value(), solver, inverse_norm);
+  if (!status.IsOk()) return Result<double>::Failure(status);
   const double condition = 1.0 / norm / inverse_norm;
   if (!std::isfinite(norm) || !std::isfinite(inverse_norm) ||
       !std::isfinite(condition) || !(condition >= std::ldexp(1.0, -32))) {
@@ -1409,20 +1378,9 @@ Result<double> CheckSelectorTransversality(
     if (!sparse.HasValue()) return Result<double>::Failure(sparse.GetStatus());
     auto status = solver.FactorizeFresh(sparse.Value());
     if (!status.IsOk()) return Result<double>::Failure(status);
-    Vector inverse_rows{rows.size()};
-    for (std::size_t column = 0U; column < rows.size(); ++column) {
-      Vector rhs{rows.size()};
-      rhs[column] = 1.0;
-      Vector solution{rows.size()};
-      status = solver.SolveCorrection(rhs, solution);
-      if (!status.IsOk()) return Result<double>::Failure(status);
-      status = hht_internal::CheckLinearSolve(sparse.Value(), rhs, solution);
-      if (!status.IsOk()) return Result<double>::Failure(status);
-      for (std::size_t row = 0U; row < rows.size(); ++row)
-        inverse_rows[row] += std::abs(solution[row]);
-    }
-    for (std::size_t row = 0U; row < rows.size(); ++row)
-      inverse_norm = (std::max)(inverse_norm, inverse_rows[row]);
+    status = hht_internal::AccumulateCheckedCanonicalNorm(
+        sparse.Value(), solver, inverse_norm);
+    if (!status.IsOk()) return Result<double>::Failure(status);
   }
   const double condition = 1.0 / norm / inverse_norm;
   if (!std::isfinite(condition) || condition < std::ldexp(1.0, -32))