refactor: Rename (I)ConfiguredProlem to just (I)Problem

AdrianDBS · AdrianDBS · commit 55c6285c2d50 · 2026-02-24T16:24:15.000+01:00
diff --git a/test/ExampleProblems/AnalyticalLeastSquaresProblem.cs b/test/ExampleProblems/AnalyticalLeastSquaresProblem.cs
@@ -5,7 +5,7 @@
 
 namespace ExampleProblems;
 
-public abstract class AnalyticalLeastSquaresProblem : IConfiguredProblem
+public abstract class AnalyticalLeastSquaresProblem : IProblem
 {
     protected AnalyticalLeastSquaresProblem(
         IReadOnlyList<double> x,
diff --git a/test/ExampleProblems/ConfiguredProblemExtensions.cs b/test/ExampleProblems/ConfiguredProblemExtensions.cs
diff --git a/test/ExampleProblems/CustomProblems/NumericalPendulumProblem.cs b/test/ExampleProblems/CustomProblems/NumericalPendulumProblem.cs
@@ -3,7 +3,7 @@
 
 namespace ExampleProblems.CustomProblems;
 
-public class NumericalPendulumProblem : IConfiguredProblem
+public class NumericalPendulumProblem : IProblem
 {
     public NumericalPendulumProblem()
     {
diff --git a/test/ExampleProblems/CustomProblems/SurfaceBiosensorBindingKineticsProblem.cs b/test/ExampleProblems/CustomProblems/SurfaceBiosensorBindingKineticsProblem.cs
@@ -40,7 +40,7 @@ public class SurfaceBiosensorBindingKineticsProblem(
     // - analyte mobility is no restricting factor for the association kinetics (no mass transport limitations)
     // (e.g. cf. https://www.sprpages.nl/data-fitting/kinetic-models/one-to-one)
     
-    public static IConfiguredProblem Global(
+    public static IProblem Global(
         IEnumerable<double> analyteConcentrationsInNanoMolar,
         DerivativeConfiguration modelDerivativeConfiguration = WithoutDerivatives,
         int randomSeed = 0)
@@ -50,9 +50,9 @@ public static IConfiguredProblem Global(
                 actualAnalyteConcentrationInNanoMolar: conc,
                 modelDerivativeConfiguration: modelDerivativeConfiguration,
                 localParameterSuffix: index.ToString(),
-                randomSeed: index + randomSeed)).Cast<IConfiguredProblem>().ToArray();
+                randomSeed: index + randomSeed)).Cast<IProblem>().ToArray();
 
-        return ConfiguredProblem.Sum(problems);
+        return Problem.Sum(problems);
     }
 
     private static readonly Func<double, IReadOnlyList<double>, double> Model = 
diff --git a/test/ExampleProblems/IProblem.cs b/test/ExampleProblems/IProblem.cs
@@ -3,7 +3,7 @@
 
 namespace ExampleProblems;
 
-public interface IConfiguredProblem
+public interface IProblem
 {
     ICostFunction Cost { get; }
     IReadOnlyCollection<double> OptimumParameterValues { get; }
diff --git a/test/ExampleProblems/MinuitTutorialProblems/MinuitTutorialProblem.cs b/test/ExampleProblems/MinuitTutorialProblems/MinuitTutorialProblem.cs
@@ -14,7 +14,7 @@ public abstract class MinuitTutorialProblem(
     Func<IReadOnlyList<double>, IReadOnlyList<double>> hessian,
     Func<IReadOnlyList<double>, IReadOnlyList<double>> hessianDiagonal,
     DerivativeConfiguration derivativeConfiguration)
-    : IConfiguredProblem
+    : IProblem
 {
     public ICostFunction Cost { get; } = derivativeConfiguration switch
     {
diff --git a/test/ExampleProblems/Problem.cs b/test/ExampleProblems/Problem.cs
@@ -3,13 +3,13 @@
 
 namespace ExampleProblems;
 
-public record ConfiguredProblem(
+public record Problem(
     ICostFunction Cost,
     IReadOnlyCollection<double> OptimumParameterValues,
     IReadOnlyCollection<ParameterConfiguration> ParameterConfigurations) 
-    : IConfiguredProblem
+    : IProblem
 {
-    public static ConfiguredProblem Sum(params IConfiguredProblem[] problems)
+    public static Problem Sum(params IProblem[] problems)
     {
         
         var parameterConfigurations = problems.Aggregate(Enumerable.Empty<ParameterConfiguration>(), (acc, next) => acc.Concat(next.ParameterConfigurations));
@@ -25,7 +25,7 @@ public static ConfiguredProblem Sum(params IConfiguredProblem[] problems)
                 throw new ArgumentException($"Parameter {config.Name} has different optimum values in both problems.");
         }
 
-        return new ConfiguredProblem(
+        return new Problem(
             CostFunction.Sum(problems.Select(p => p.Cost).ToArray()),
             parameters.Select(p => p.Optimum).ToList(),
             parameters.Select(p => p.Config).ToList());
diff --git a/test/ExampleProblems/ProblemExtensions.cs b/test/ExampleProblems/ProblemExtensions.cs
@@ -0,0 +1,7 @@
+namespace ExampleProblems;
+
+public static class ProblemExtensions
+{
+    public static double InitialCostValue(this IProblem problem) =>
+        problem.Cost.ValueFor(problem.ParameterConfigurations);
+}
diff --git a/test/minuit2.net.Benchmarks/ProblemExtensions.cs b/test/minuit2.net.Benchmarks/ProblemExtensions.cs
@@ -3,9 +3,9 @@
 
 namespace minuit2.net.Benchmarks;
 
-internal static class ConfiguredProblemExtensions
+internal static class ProblemExtensions
 {
-    public static IMinimizationResult MinimizeWithMigrad(this IConfiguredProblem problem, Strategy strategy)
+    public static IMinimizationResult MinimizeWithMigrad(this IProblem problem, Strategy strategy)
     {
         var minimizerConfiguration = new MinimizerConfiguration(strategy);
         return Minimizer.Migrad.Minimize(problem.Cost, problem.ParameterConfigurations, minimizerConfiguration);
diff --git a/test/minuit2.net.UnitTests/Any_gradient_based_minimizer.spec.cs b/test/minuit2.net.UnitTests/Any_gradient_based_minimizer.spec.cs
@@ -58,7 +58,7 @@ public void when_asked_to_minimize_a_cost_function_with_an_analytical_hessian_di
                  "occasionally reports non-convergence — even at the true minimum — due to its unreliable convergence " +
                  "criteria (see the Minuit docs: '...it would not even know if it did converge').")]
     public void when_minimizing_a_well_posed_problem_converges_to_a_valid_cost_function_minimum(
-        IConfiguredProblem problem,
+        IProblem problem,
         Strategy strategy)
     { 
         var result = _minimizer.Minimize(problem.Cost, problem.ParameterConfigurations);
@@ -73,7 +73,7 @@ public void when_minimizing_a_well_posed_problem_converges_to_a_valid_cost_funct
     
     [TestCaseSource(nameof(WellPosedMinimizationProblems))]
     public void when_minimizing_a_well_posed_problem_yields_parameter_values_that_agree_with_the_optimum_values_within_3_sigma_tolerance(
-        IConfiguredProblem problem,
+        IProblem problem,
         Strategy strategy)
     { 
         var result = _minimizer.Minimize(problem.Cost, problem.ParameterConfigurations);
@@ -242,7 +242,7 @@ public void when_minimizing_a_cost_function_sum_of_independent_components_with_d
             c3: CubicPolynomialProblem.DefaultC3.WithSuffix("2"),
             derivativeConfiguration: derivativeConfiguration, 
             errorDefinitionInSigma: 2);
-        var sumProblem = ConfiguredProblem.Sum(problem1, problem2);
+        var sumProblem = Problem.Sum(problem1, problem2);
         var minimizerConfiguration = new MinimizerConfiguration(strategy);
 
         var problem1Result = _minimizer.Minimize(problem1, minimizerConfiguration);
@@ -266,7 +266,7 @@ public void when_minimizing_a_cost_function_sum_of_independent_components_with_d
             c3: CubicPolynomialProblem.DefaultC3.WithSuffix("2"),
             derivativeConfiguration: derivativeConfiguration, 
             errorDefinitionInSigma: 2);
-        var sumProblem = ConfiguredProblem.Sum(problem1, problem2);
+        var sumProblem = Problem.Sum(problem1, problem2);
         var minimizerConfiguration = new MinimizerConfiguration(Strategy.Fast);
 
         var problem1Result = _minimizer.MinimizeAndRefineErrors(problem1, minimizerConfiguration);
@@ -282,8 +282,8 @@ public void when_minimizing_a_cost_function_sum_of_independent_components_with_d
     public void when_minimizing_a_cost_function_sum_where_only_some_components_have_an_analytical_hessian_yields_the_same_result_as_if_none_had_an_analytical_gradient(
         [Values] Strategy strategy)
     {
-        var problem = ConfiguredProblem.Sum(ProblemComponent1(WithGradientAndHessian), ProblemComponent2());
-        var referenceProblem = ConfiguredProblem.Sum(ProblemComponent1(WithoutDerivatives), ProblemComponent2());
+        var problem = Problem.Sum(Problem1(WithGradientAndHessian), Problem2());
+        var referenceProblem = Problem.Sum(Problem1(WithoutDerivatives), Problem2());
         var minimizerConfiguration = new MinimizerConfiguration(strategy);
         
         var result = _minimizer.Minimize(problem, minimizerConfiguration);
@@ -292,10 +292,10 @@ public void when_minimizing_a_cost_function_sum_where_only_some_components_have_
         result.Should().Match(referenceResult);
         return;
 
-        QuadraticPolynomialProblem ProblemComponent1(DerivativeConfiguration derivativeConfiguration) =>
+        QuadraticPolynomialProblem Problem1(DerivativeConfiguration derivativeConfiguration) =>
             new(derivativeConfiguration: derivativeConfiguration);
         
-        QuadraticPolynomialProblem ProblemComponent2() =>
+        QuadraticPolynomialProblem Problem2() =>
             new(c1: QuadraticPolynomialProblem.DefaultC1.WithSuffix("2"), 
                 c2: QuadraticPolynomialProblem.DefaultC2.WithSuffix("2"));
     }
@@ -305,8 +305,8 @@ public void when_minimizing_a_cost_function_sum_where_all_components_have_analyt
         [Values(1, 2)] double errorDefinitionOfComponent1,
         [Values] Strategy strategy)
     {
-        var problem = ConfiguredProblem.Sum(ProblemComponent1(WithGradientAndHessian), ProblemComponent2(WithGradientAndHessian));
-        var referenceProblem = ConfiguredProblem.Sum(ProblemComponent1(WithoutDerivatives), ProblemComponent2(WithoutDerivatives));
+        var problem = Problem.Sum(Problem1(WithGradientAndHessian), Problem2(WithGradientAndHessian));
+        var referenceProblem = Problem.Sum(Problem1(WithoutDerivatives), Problem2(WithoutDerivatives));
         var minimizerConfiguration = new MinimizerConfiguration(strategy);
         
         var result = _minimizer.Minimize(problem, minimizerConfiguration);
@@ -317,10 +317,10 @@ public void when_minimizing_a_cost_function_sum_where_all_components_have_analyt
             .HaveFewerFunctionCallsThan(referenceResult);
         return;
 
-        QuadraticPolynomialProblem ProblemComponent1(DerivativeConfiguration derivativeConfiguration) =>
+        QuadraticPolynomialProblem Problem1(DerivativeConfiguration derivativeConfiguration) =>
             new(derivativeConfiguration: derivativeConfiguration, errorDefinitionInSigma: errorDefinitionOfComponent1);
 
-        QuadraticPolynomialProblem ProblemComponent2(DerivativeConfiguration derivativeConfiguration) =>
+        QuadraticPolynomialProblem Problem2(DerivativeConfiguration derivativeConfiguration) =>
             new(c1: QuadraticPolynomialProblem.DefaultC1.WithSuffix("2"), 
                 c2: QuadraticPolynomialProblem.DefaultC2.WithSuffix("2"), 
                 derivativeConfiguration: derivativeConfiguration);
diff --git a/test/minuit2.net.UnitTests/Any_minimizer.spec.cs b/test/minuit2.net.UnitTests/Any_minimizer.spec.cs
@@ -25,14 +25,14 @@ protected static IEnumerable<TestCaseData> WellPosedMinimizationProblems()
             yield return TestCase(new SurfaceBiosensorBindingKineticsProblem(), nameof(SurfaceBiosensorBindingKineticsProblem));
             continue;
 
-            TestCaseData TestCase(IConfiguredProblem problem, string problemName) =>
+            TestCaseData TestCase(IProblem problem, string problemName) =>
                 new TestCaseData(problem, strategy).SetName($"{problemName} ({strategy})");
         }
     }
 
     [TestCaseSource(nameof(WellPosedMinimizationProblems))]
     public void when_minimizing_a_well_posed_problem_finds_the_optimum_parameter_values(
-        IConfiguredProblem problem,
+        IProblem problem,
         Strategy strategy)
     { 
         var minimizerConfiguration = new MaximumAccuracyMinimizerConfiguration(strategy);
@@ -64,7 +64,7 @@ private static IEnumerable<TestCaseData> ChallengingMinimizationProblems()
             yield return TestCase(new Bennett5Problem(derivativeConfiguration), nameof(Bennett5Problem));
             continue;
 
-            TestCaseData TestCase(IConfiguredProblem problem, string problemName) => 
+            TestCaseData TestCase(IProblem problem, string problemName) => 
                 new TestCaseData(problem, strategy).SetName($"{problemName}.{derivativeConfiguration} ({strategy})");
         }
     }
@@ -75,7 +75,7 @@ public Task fails_for_the_following_challenging_problems()
         var report = new List<string>();
         foreach (var testCase in ChallengingMinimizationProblems().OrderBy(x => x.TestName))
         {
-            var problem = (IConfiguredProblem)testCase.Arguments[0]!;
+            var problem = (IProblem)testCase.Arguments[0]!;
             var strategy = (Strategy)testCase.Arguments[1]!;
             
             var minimizerConfiguration = new MaximumAccuracyMinimizerConfiguration(strategy);
@@ -302,7 +302,7 @@ public void when_minimizing_a_cost_function_sum_of_independent_components_with_d
             c2: QuadraticPolynomialProblem.DefaultC2.WithSuffix("2"),
             derivativeConfiguration: derivativeConfiguration, 
             errorDefinitionInSigma: 2);
-        var problemSum = ConfiguredProblem.Sum(problem1, problem2);
+        var problemSum = Problem.Sum(problem1, problem2);
         var minimizerConfiguration = new MaximumAccuracyMinimizerConfiguration(strategy);
 
         var problem1Result = minimizer.Minimize(problem1, minimizerConfiguration);
diff --git a/test/minuit2.net.UnitTests/Combined_minimizer.spec.cs b/test/minuit2.net.UnitTests/Combined_minimizer.spec.cs
@@ -15,7 +15,7 @@ public class The_combined_minimizer() : Any_gradient_based_minimizer(CombinedMin
                  "Migrad shouldn't face issues, there should be no difference between results obtained by Migrad and " +
                  "the combined minimizer.")]
     public void when_minimizing_a_well_posed_problem_yields_the_same_result_as_the_migrad_minimizer(
-        IConfiguredProblem problem, 
+        IProblem problem, 
         Strategy strategy)
     {
         var result = CombinedMinimizer.Minimize(problem.Cost, problem.ParameterConfigurations);
diff --git a/test/minuit2.net.UnitTests/Migrad_minimizer.spec.cs b/test/minuit2.net.UnitTests/Migrad_minimizer.spec.cs
@@ -239,7 +239,7 @@ public void not_sharing_any_parameters_where_some_have_unknown_data_errors_and_s
                 c3: CubicPolynomialProblem.DefaultC3.WithSuffix("2"),
                 hasYErrors: false,
                 derivativeConfiguration: derivativeConfiguration);
-            var sumProblem = ConfiguredProblem.Sum(problem1, problem2);
+            var sumProblem = Problem.Sum(problem1, problem2);
             var minimizerConfiguration = new MaximumAccuracyMinimizerConfiguration(strategy);
             
             var component1Result = MigradMinimizer.MinimizeAndRefineErrors(problem1, minimizerConfiguration);
@@ -269,7 +269,7 @@ public void with_defined_data_uncertainties_yields_the_expected_result(
                 c1: Variable("c1_2", -2.1),
                 c3: Variable("c3_2", -0.15),
                 derivativeConfiguration: derivativeConfiguration2);
-            var sumProblem = ConfiguredProblem.Sum(problem1, problem2);
+            var sumProblem = Problem.Sum(problem1, problem2);
 
             var result = MigradMinimizer.Minimize(sumProblem);
             
@@ -301,7 +301,7 @@ public void with_some_having_unknown_data_errors_yields_the_expected_result(
         {
             var problem1 = new CubicPolynomialProblem(derivativeConfiguration: derivativeConfiguration1);
             var problem2 = new CubicPolynomialProblem(derivativeConfiguration: derivativeConfiguration2, hasYErrors: false);
-            var sumProblem = ConfiguredProblem.Sum(problem1, problem2);
+            var sumProblem = Problem.Sum(problem1, problem2);
 
             var result = MigradMinimizer.Minimize(sumProblem);
             
@@ -331,7 +331,7 @@ public void with_some_having_unknown_data_errors_and_subsequently_applying_error
         {
             var problem1 = new CubicPolynomialProblem(derivativeConfiguration: derivativeConfiguration1);
             var problem2 = new CubicPolynomialProblem(derivativeConfiguration: derivativeConfiguration2, hasYErrors: false);
-            var sumProblem = ConfiguredProblem.Sum(problem1, problem2);
+            var sumProblem = Problem.Sum(problem1, problem2);
 
             var result = MigradMinimizer.MinimizeAndRefineErrors(sumProblem);
             
diff --git a/test/minuit2.net.UnitTests/TestUtilities/MinimizerExtensions.cs b/test/minuit2.net.UnitTests/TestUtilities/MinimizerExtensions.cs
@@ -7,15 +7,15 @@ internal static class MinimizerExtensions
 {
     public static IMinimizationResult Minimize(
         this IMinimizer minimizer, 
-        IConfiguredProblem problem, 
+        IProblem problem, 
         MinimizerConfiguration? minimizerConfiguration = null)
     {
         return minimizer.Minimize(problem.Cost, problem.ParameterConfigurations, minimizerConfiguration);
     }
     
     public static IMinimizationResult MinimizeAndRefineErrors(
         this IMinimizer minimizer, 
-        IConfiguredProblem problem, 
+        IProblem problem, 
         MinimizerConfiguration? minimizerConfiguration = null)
     {
         var result = minimizer.Minimize(problem, minimizerConfiguration);
diff --git a/test/minuit2.net.UnitTests/TestUtilities/ProblemExtensions.cs b/test/minuit2.net.UnitTests/TestUtilities/ProblemExtensions.cs
@@ -3,9 +3,9 @@
 
 namespace minuit2.net.UnitTests.TestUtilities;
 
-internal static class ConfiguredProblemExtensions
+internal static class ProblemExtensions
 {
-    public static IConfiguredProblem WithVariablesAnywhereCloseToOptimumValues(this IConfiguredProblem problem)
+    public static IProblem WithVariablesAnywhereCloseToOptimumValues(this IProblem problem)
     {
         const double maximumRelativeBias = 0.1;
         var newParameterConfigurations = problem.ParameterConfigurations.Zip(problem.OptimumParameterValues, 
@@ -14,7 +14,7 @@ public static IConfiguredProblem WithVariablesAnywhereCloseToOptimumValues(this
                 : Variable(p.Name, AnyValueCloseTo(optimumValue, maximumRelativeBias), p.LowerLimit, p.UpperLimit))
             .ToArray();
         
-        return new ConfiguredProblem(problem.Cost, problem.OptimumParameterValues, newParameterConfigurations);
+        return new Problem(problem.Cost, problem.OptimumParameterValues, newParameterConfigurations);
     }
     
     private static double AnyValueCloseTo(double value, double maximumRelativeBias)

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`
`6`	`6`	`namespace ExampleProblems;`
`7`	`7`
`8`		`-public abstract class AnalyticalLeastSquaresProblem : IConfiguredProblem`
	`8`	`+public abstract class AnalyticalLeastSquaresProblem : IProblem`
`9`	`9`	`{`
`10`	`10`	`protected AnalyticalLeastSquaresProblem(`
`11`	`11`	`IReadOnlyList<double> x,`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`
`4`	`4`	`namespace ExampleProblems.CustomProblems;`
`5`	`5`
`6`		`-public class NumericalPendulumProblem : IConfiguredProblem`
	`6`	`+public class NumericalPendulumProblem : IProblem`
`7`	`7`	`{`
`8`	`8`	`public NumericalPendulumProblem()`
`9`	`9`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`
`4`	`4`	`namespace ExampleProblems;`
`5`	`5`
`6`		`-public interface IConfiguredProblem`
	`6`	`+public interface IProblem`
`7`	`7`	`{`
`8`	`8`	`ICostFunction Cost { get; }`
`9`	`9`	`IReadOnlyCollection<double> OptimumParameterValues { get; }`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public abstract class MinuitTutorialProblem(`
`14`	`14`	`Func<IReadOnlyList<double>, IReadOnlyList<double>> hessian,`
`15`	`15`	`Func<IReadOnlyList<double>, IReadOnlyList<double>> hessianDiagonal,`
`16`	`16`	`DerivativeConfiguration derivativeConfiguration)`
`17`		`- : IConfiguredProblem`
	`17`	`+ : IProblem`
`18`	`18`	`{`
`19`	`19`	`public ICostFunction Cost { get; } = derivativeConfiguration switch`
`20`	`20`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3,9 +3,9 @@`
`3`	`3`
`4`	`4`	`namespace minuit2.net.Benchmarks;`
`5`	`5`
`6`		`-internal static class ConfiguredProblemExtensions`
	`6`	`+internal static class ProblemExtensions`
`7`	`7`	`{`
`8`		`- public static IMinimizationResult MinimizeWithMigrad(this IConfiguredProblem problem, Strategy strategy)`
	`8`	`+ public static IMinimizationResult MinimizeWithMigrad(this IProblem problem, Strategy strategy)`
`9`	`9`	`{`
`10`	`10`	`var minimizerConfiguration = new MinimizerConfiguration(strategy);`
`11`	`11`	`return Minimizer.Migrad.Minimize(problem.Cost, problem.ParameterConfigurations, minimizerConfiguration);`