From 2628b906a054bba0f1e127ae97ef7070d9f4244c Mon Sep 17 00:00:00 2001 From: Christoph Ruegg Date: Thu, 14 May 2015 19:42:39 +0200 Subject: [PATCH] Optimization: first pass code style fix --- src/Numerics/Optimization/BaseEvaluation.cs | 31 ++--- src/Numerics/Optimization/Exceptions.cs | 3 - src/Numerics/Optimization/IEvaluation.cs | 7 +- .../Optimization/IUnconstrainedMinimizer.cs | 9 +- .../Implementation/LineSearchOutput.cs | 13 +- .../Implementation/NullEvaluation.cs | 14 +-- .../Implementation/ObjectiveChecker.cs | 67 +++++----- .../Implementation/WeakWolfeLineSearch.cs | 119 +++++++++--------- .../Optimization/MinimizationOutput.cs | 14 +-- .../MinimizationWithLineSearchOutput.cs | 15 +-- src/Numerics/Optimization/NewtonMinimizer.cs | 78 ++++++------ .../OptimizationTests/TestNewtonMinimizer.cs | 6 +- 12 files changed, 168 insertions(+), 208 deletions(-) diff --git a/src/Numerics/Optimization/BaseEvaluation.cs b/src/Numerics/Optimization/BaseEvaluation.cs index c1a703bc..b2ac67b3 100644 --- a/src/Numerics/Optimization/BaseEvaluation.cs +++ b/src/Numerics/Optimization/BaseEvaluation.cs @@ -1,9 +1,4 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - -using MathNet.Numerics.LinearAlgebra; +using MathNet.Numerics.LinearAlgebra; namespace MathNet.Numerics.Optimization { @@ -19,23 +14,23 @@ namespace MathNet.Numerics.Optimization public bool GradientSupported { get; private set; } public bool HessianSupported { get; private set; } - protected BaseEvaluation(bool gradient_supported, bool hessian_supported) + protected BaseEvaluation(bool gradientSupported, bool hessianSupported) { Status = EvaluationStatus.None; - this.GradientSupported = gradient_supported; - this.HessianSupported = hessian_supported; + GradientSupported = gradientSupported; + HessianSupported = hessianSupported; } public Vector Point { get { - return this.PointRaw; + return PointRaw; } set { - this.PointRaw = value; - this.Status = EvaluationStatus.None; + PointRaw = value; + Status = EvaluationStatus.None; } } @@ -45,7 +40,7 @@ namespace MathNet.Numerics.Optimization { if (!Status.HasFlag(EvaluationStatus.Value)) { - setValue(); + SetValue(); Status |= EvaluationStatus.Value; } return ValueRaw; @@ -57,7 +52,7 @@ namespace MathNet.Numerics.Optimization { if (!Status.HasFlag(EvaluationStatus.Gradient)) { - setGradient(); + SetGradient(); Status |= EvaluationStatus.Gradient; } return GradientRaw; @@ -69,16 +64,16 @@ namespace MathNet.Numerics.Optimization { if (!Status.HasFlag(EvaluationStatus.Hessian)) { - setHessian(); + SetHessian(); Status |= EvaluationStatus.Hessian; } return HessianRaw; } } - protected abstract void setValue(); - protected abstract void setGradient(); - protected abstract void setHessian(); + protected abstract void SetValue(); + protected abstract void SetGradient(); + protected abstract void SetHessian(); public abstract IEvaluation CreateNew(); } } diff --git a/src/Numerics/Optimization/Exceptions.cs b/src/Numerics/Optimization/Exceptions.cs index 7999b093..741a9815 100644 --- a/src/Numerics/Optimization/Exceptions.cs +++ b/src/Numerics/Optimization/Exceptions.cs @@ -1,7 +1,4 @@ using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; namespace MathNet.Numerics.Optimization { diff --git a/src/Numerics/Optimization/IEvaluation.cs b/src/Numerics/Optimization/IEvaluation.cs index e1f3c18d..678e970b 100644 --- a/src/Numerics/Optimization/IEvaluation.cs +++ b/src/Numerics/Optimization/IEvaluation.cs @@ -1,8 +1,5 @@ -using MathNet.Numerics.LinearAlgebra; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; +using System; +using MathNet.Numerics.LinearAlgebra; namespace MathNet.Numerics.Optimization { diff --git a/src/Numerics/Optimization/IUnconstrainedMinimizer.cs b/src/Numerics/Optimization/IUnconstrainedMinimizer.cs index 37ac4928..ad2ba208 100644 --- a/src/Numerics/Optimization/IUnconstrainedMinimizer.cs +++ b/src/Numerics/Optimization/IUnconstrainedMinimizer.cs @@ -1,14 +1,9 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using MathNet.Numerics.LinearAlgebra; +using MathNet.Numerics.LinearAlgebra; namespace MathNet.Numerics.Optimization { public interface IUnconstrainedMinimizer { - MinimizationOutput FindMinimum(IEvaluation objective, Vector initial_guess); + MinimizationOutput FindMinimum(IEvaluation objective, Vector initialGuess); } - } diff --git a/src/Numerics/Optimization/Implementation/LineSearchOutput.cs b/src/Numerics/Optimization/Implementation/LineSearchOutput.cs index 01a28276..b20a0f20 100644 --- a/src/Numerics/Optimization/Implementation/LineSearchOutput.cs +++ b/src/Numerics/Optimization/Implementation/LineSearchOutput.cs @@ -1,18 +1,13 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - -namespace MathNet.Numerics.Optimization.Implementation +namespace MathNet.Numerics.Optimization.Implementation { public class LineSearchOutput : MinimizationOutput { public double FinalStep { get; private set; } - public LineSearchOutput(IEvaluation function_info, int iterations, double final_step, ExitCondition reason_for_exit) - : base(function_info, iterations, reason_for_exit) + public LineSearchOutput(IEvaluation functionInfo, int iterations, double finalStep, ExitCondition reasonForExit) + : base(functionInfo, iterations, reasonForExit) { - this.FinalStep = final_step; + FinalStep = finalStep; } } } diff --git a/src/Numerics/Optimization/Implementation/NullEvaluation.cs b/src/Numerics/Optimization/Implementation/NullEvaluation.cs index 521419f3..32caece2 100644 --- a/src/Numerics/Optimization/Implementation/NullEvaluation.cs +++ b/src/Numerics/Optimization/Implementation/NullEvaluation.cs @@ -1,30 +1,26 @@ using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - using MathNet.Numerics.LinearAlgebra; namespace MathNet.Numerics.Optimization.Implementation { public class NullEvaluation : BaseEvaluation { - public NullEvaluation(Vector point) + public NullEvaluation(Vector point) : base(false, false) { - this.Point = point; + Point = point; } - protected override void setValue() + protected override void SetValue() { throw new NotImplementedException(); } - protected override void setGradient() + protected override void SetGradient() { throw new NotImplementedException(); } - protected override void setHessian() + protected override void SetHessian() { throw new NotImplementedException(); } diff --git a/src/Numerics/Optimization/Implementation/ObjectiveChecker.cs b/src/Numerics/Optimization/Implementation/ObjectiveChecker.cs index dee66755..961366e0 100644 --- a/src/Numerics/Optimization/Implementation/ObjectiveChecker.cs +++ b/src/Numerics/Optimization/Implementation/ObjectiveChecker.cs @@ -1,34 +1,31 @@ using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; using MathNet.Numerics.LinearAlgebra; namespace MathNet.Numerics.Optimization.Implementation { public class CheckedEvaluation : IEvaluation { + private bool _valueChecked; + private bool _gradientChecked; + private bool _hessianChecked; + public IEvaluation InnerEvaluation { get; private set; } - private bool ValueChecked; - private bool GradientChecked; - private bool HessianChecked; public Action ValueChecker { get; private set; } public Action GradientChecker { get; private set; } public Action HessianChecker { get; private set; } - - public CheckedEvaluation(IEvaluation objective, Action value_checker, Action gradient_checker, Action hessian_checker) + public CheckedEvaluation(IEvaluation objective, Action valueChecker, Action gradientChecker, Action hessianChecker) { - this.InnerEvaluation = objective; - this.ValueChecker = value_checker; - this.GradientChecker = gradient_checker; - this.HessianChecker = hessian_checker; + InnerEvaluation = objective; + ValueChecker = valueChecker; + GradientChecker = gradientChecker; + HessianChecker = hessianChecker; } public Vector Point { - get { return this.InnerEvaluation.Point; } - set { this.InnerEvaluation.Point = value; } + get { return InnerEvaluation.Point; } + set { InnerEvaluation.Point = value; } } public double Value @@ -36,21 +33,21 @@ namespace MathNet.Numerics.Optimization.Implementation get { - if (!this.ValueChecked) + if (!_valueChecked) { double tmp; try { - tmp = this.InnerEvaluation.Value; + tmp = InnerEvaluation.Value; } catch (Exception e) { - throw new EvaluationException("Objective function evaluation failed.", this.InnerEvaluation, e); + throw new EvaluationException("Objective function evaluation failed.", InnerEvaluation, e); } - this.ValueChecker(this.InnerEvaluation); - this.ValueChecked = true; + ValueChecker(InnerEvaluation); + _valueChecked = true; } - return this.InnerEvaluation.Value; + return InnerEvaluation.Value; } } @@ -59,21 +56,21 @@ namespace MathNet.Numerics.Optimization.Implementation get { - if (!this.GradientChecked) + if (!_gradientChecked) { Vector tmp; try { - tmp = this.InnerEvaluation.Gradient; + tmp = InnerEvaluation.Gradient; } catch (Exception e) { - throw new EvaluationException("Objective gradient evaluation failed.", this.InnerEvaluation, e); + throw new EvaluationException("Objective gradient evaluation failed.", InnerEvaluation, e); } - this.GradientChecker(this.InnerEvaluation); - this.GradientChecked = true; + GradientChecker(InnerEvaluation); + _gradientChecked = true; } - return this.InnerEvaluation.Gradient; + return InnerEvaluation.Gradient; } } @@ -82,37 +79,37 @@ namespace MathNet.Numerics.Optimization.Implementation get { - if (!this.HessianChecked) + if (!_hessianChecked) { Matrix tmp; try { - tmp = this.InnerEvaluation.Hessian; + tmp = InnerEvaluation.Hessian; } catch (Exception e) { - throw new EvaluationException("Objective hessian evaluation failed.", this.InnerEvaluation, e); + throw new EvaluationException("Objective hessian evaluation failed.", InnerEvaluation, e); } - this.HessianChecker(InnerEvaluation); - this.HessianChecked = true; + HessianChecker(InnerEvaluation); + _hessianChecked = true; } - return this.InnerEvaluation.Hessian; + return InnerEvaluation.Hessian; } } public IEvaluation CreateNew() { - return new CheckedEvaluation(this.InnerEvaluation, this.ValueChecker, this.GradientChecker, this.HessianChecker); + return new CheckedEvaluation(InnerEvaluation, ValueChecker, GradientChecker, HessianChecker); } public bool GradientSupported { - get { return this.InnerEvaluation.GradientSupported; } + get { return InnerEvaluation.GradientSupported; } } public bool HessianSupported { - get { return this.InnerEvaluation.HessianSupported; } + get { return InnerEvaluation.HessianSupported; } } } } diff --git a/src/Numerics/Optimization/Implementation/WeakWolfeLineSearch.cs b/src/Numerics/Optimization/Implementation/WeakWolfeLineSearch.cs index 5a6642b5..c5ace961 100644 --- a/src/Numerics/Optimization/Implementation/WeakWolfeLineSearch.cs +++ b/src/Numerics/Optimization/Implementation/WeakWolfeLineSearch.cs @@ -1,117 +1,122 @@ using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - using MathNet.Numerics.LinearAlgebra; namespace MathNet.Numerics.Optimization.Implementation { public class WeakWolfeLineSearch { - public double C1 { get; set; } - public double C2 { get; set; } - public double ParameterTolerance { get; set; } - public int MaximumIterations { get; set; } + readonly double _c1; + readonly double _c2; + readonly double _parameterTolerance; + readonly int _maximumIterations; - public WeakWolfeLineSearch(double c1, double c2, double parameter_tolerance, int max_iterations = 10) + public WeakWolfeLineSearch(double c1, double c2, double parameterTolerance, int maxIterations = 10) { - this.C1 = c1; - this.C2 = c2; - this.ParameterTolerance = parameter_tolerance; - this.MaximumIterations = max_iterations; + _c1 = c1; + _c2 = c2; + _parameterTolerance = parameterTolerance; + _maximumIterations = maxIterations; } // Implemented following http://www.math.washington.edu/~burke/crs/408/lectures/L9-weak-Wolfe.pdf - public LineSearchOutput FindConformingStep(IEvaluation objective, IEvaluation starting_point, Vector search_direction, double initial_step) + public LineSearchOutput FindConformingStep(IEvaluation objective, IEvaluation startingPoint, Vector searchDirection, double initialStep) { - if (!(objective is CheckedEvaluation)) - objective = new CheckedEvaluation(objective, this.ValidateValue, this.ValidateGradient, null); + { + objective = new CheckedEvaluation(objective, ValidateValue, ValidateGradient, null); + } - double lower_bound = 0.0; - double upper_bound = Double.PositiveInfinity; - double step = initial_step; + double lowerBound = 0.0; + double upperBound = Double.PositiveInfinity; + double step = initialStep; - double initial_value = starting_point.Value; - Vector initial_gradient = starting_point.Gradient; + double initialValue = startingPoint.Value; + Vector initialGradient = startingPoint.Gradient; - double initial_dd = search_direction * initial_gradient; + double initialDd = searchDirection * initialGradient; int ii; - IEvaluation candidate_eval = objective.CreateNew(); - MinimizationOutput.ExitCondition reason_for_exit = MinimizationOutput.ExitCondition.None; - for (ii = 0; ii < this.MaximumIterations; ++ii) + IEvaluation candidateEval = objective.CreateNew(); + MinimizationOutput.ExitCondition reasonForExit = MinimizationOutput.ExitCondition.None; + for (ii = 0; ii < _maximumIterations; ++ii) { - candidate_eval.Point = starting_point.Point + search_direction * step; + candidateEval.Point = startingPoint.Point + searchDirection * step; - double step_dd = search_direction * candidate_eval.Gradient; + double stepDd = searchDirection * candidateEval.Gradient; - if (candidate_eval.Value > initial_value + this.C1 * step * initial_dd) + if (candidateEval.Value > initialValue + _c1 * step * initialDd) { - upper_bound = step; - step = 0.5 * (lower_bound + upper_bound); + upperBound = step; + step = 0.5 * (lowerBound + upperBound); } - else if (step_dd < this.C2 * initial_dd) + else if (stepDd < _c2 * initialDd) { - lower_bound = step; - step = Double.IsPositiveInfinity(upper_bound) ? 2 * lower_bound : 0.5 * (lower_bound + upper_bound); + lowerBound = step; + step = Double.IsPositiveInfinity(upperBound) ? 2 * lowerBound : 0.5 * (lowerBound + upperBound); } else { - reason_for_exit = MinimizationOutput.ExitCondition.WeakWolfeCriteria; + reasonForExit = MinimizationOutput.ExitCondition.WeakWolfeCriteria; break; } - if (!Double.IsInfinity(upper_bound)) + if (!Double.IsInfinity(upperBound)) { - double max_rel_change = 0.0; - for (int jj = 0; jj < candidate_eval.Point.Count; ++jj) + double maxRelChange = 0.0; + for (int jj = 0; jj < candidateEval.Point.Count; ++jj) { - double tmp = Math.Abs(search_direction[jj] * (upper_bound - lower_bound)) / Math.Max(Math.Abs(candidate_eval.Point[jj]), 1.0); - max_rel_change = Math.Max(max_rel_change, tmp); + double tmp = Math.Abs(searchDirection[jj] * (upperBound - lowerBound)) / Math.Max(Math.Abs(candidateEval.Point[jj]), 1.0); + maxRelChange = Math.Max(maxRelChange, tmp); } - if (max_rel_change < this.ParameterTolerance) + if (maxRelChange < _parameterTolerance) { - reason_for_exit = MinimizationOutput.ExitCondition.LackOfProgress; + reasonForExit = MinimizationOutput.ExitCondition.LackOfProgress; break; } } } - if (ii == this.MaximumIterations && Double.IsPositiveInfinity(upper_bound)) - throw new MaximumIterationsException(String.Format("Maximum iterations ({0}) reached. Function appears to be unbounded in search direction.", this.MaximumIterations)); - else if (ii == this.MaximumIterations) - throw new MaximumIterationsException(String.Format("Maximum iterations ({0}) reached.", this.MaximumIterations)); - else - return new LineSearchOutput(candidate_eval, ii, step, reason_for_exit); + if (ii == _maximumIterations && Double.IsPositiveInfinity(upperBound)) + { + throw new MaximumIterationsException(String.Format("Maximum iterations ({0}) reached. Function appears to be unbounded in search direction.", _maximumIterations)); + } + + if (ii == _maximumIterations) + { + throw new MaximumIterationsException(String.Format("Maximum iterations ({0}) reached.", _maximumIterations)); + } + + return new LineSearchOutput(candidateEval, ii, step, reasonForExit); } - private bool Conforms(IEvaluation starting_point, Vector search_direction, double step, IEvaluation ending_point) + bool Conforms(IEvaluation startingPoint, Vector searchDirection, double step, IEvaluation endingPoint) { + bool sufficientDecrease = endingPoint.Value <= startingPoint.Value + _c1 * step * (startingPoint.Gradient * searchDirection); + bool notTooSteep = endingPoint.Gradient * searchDirection >= _c2 * startingPoint.Gradient * searchDirection; - bool sufficient_decrease = ending_point.Value <= starting_point.Value + this.C1 * step * (starting_point.Gradient * search_direction); - bool not_too_steep = ending_point.Gradient * search_direction >= this.C2 * starting_point.Gradient * search_direction; - - return step > 0 && sufficient_decrease && not_too_steep; + return step > 0 && sufficientDecrease && notTooSteep; } - private void ValidateValue(IEvaluation eval) + void ValidateValue(IEvaluation eval) { - if (!this.IsFinite(eval.Value)) + if (!IsFinite(eval.Value)) + { throw new EvaluationException(String.Format("Non-finite value returned by objective function: {0}", eval.Value), eval); + } } - private void ValidateGradient(IEvaluation eval) + void ValidateGradient(IEvaluation eval) { foreach (double x in eval.Gradient) - if (!this.IsFinite(x)) + { + if (!IsFinite(x)) { throw new EvaluationException(String.Format("Non-finite value returned by gradient: {0}", x), eval); } + } } - private bool IsFinite(double x) + bool IsFinite(double x) { return !(Double.IsNaN(x) || Double.IsInfinity(x)); } diff --git a/src/Numerics/Optimization/MinimizationOutput.cs b/src/Numerics/Optimization/MinimizationOutput.cs index d80e4e80..3d4d3827 100644 --- a/src/Numerics/Optimization/MinimizationOutput.cs +++ b/src/Numerics/Optimization/MinimizationOutput.cs @@ -1,8 +1,4 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using MathNet.Numerics.LinearAlgebra; +using MathNet.Numerics.LinearAlgebra; namespace MathNet.Numerics.Optimization { @@ -15,11 +11,11 @@ namespace MathNet.Numerics.Optimization public int Iterations { get; private set; } public ExitCondition ReasonForExit { get; private set; } - public MinimizationOutput(IEvaluation function_info, int iterations, ExitCondition reason_for_exit) + public MinimizationOutput(IEvaluation functionInfo, int iterations, ExitCondition reasonForExit) { - this.FunctionInfoAtMinimum = function_info; - this.Iterations = iterations; - this.ReasonForExit = reason_for_exit; + FunctionInfoAtMinimum = functionInfo; + Iterations = iterations; + ReasonForExit = reasonForExit; } } } diff --git a/src/Numerics/Optimization/MinimizationWithLineSearchOutput.cs b/src/Numerics/Optimization/MinimizationWithLineSearchOutput.cs index 2cd00ad9..e7f2aadf 100644 --- a/src/Numerics/Optimization/MinimizationWithLineSearchOutput.cs +++ b/src/Numerics/Optimization/MinimizationWithLineSearchOutput.cs @@ -1,20 +1,15 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - -namespace MathNet.Numerics.Optimization +namespace MathNet.Numerics.Optimization { public class MinimizationWithLineSearchOutput : MinimizationOutput { public int TotalLineSearchIterations { get; private set; } public int IterationsWithNonTrivialLineSearch { get; private set; } - public MinimizationWithLineSearchOutput(IEvaluation function_info, int iterations, ExitCondition reason_for_exit, int total_line_search_iterations, int iterations_with_non_trivial_line_search) - : base(function_info, iterations, reason_for_exit) + public MinimizationWithLineSearchOutput(IEvaluation functionInfo, int iterations, ExitCondition reasonForExit, int totalLineSearchIterations, int iterationsWithNonTrivialLineSearch) + : base(functionInfo, iterations, reasonForExit) { - this.TotalLineSearchIterations = total_line_search_iterations; - this.IterationsWithNonTrivialLineSearch = iterations_with_non_trivial_line_search; + TotalLineSearchIterations = totalLineSearchIterations; + IterationsWithNonTrivialLineSearch = iterationsWithNonTrivialLineSearch; } } } diff --git a/src/Numerics/Optimization/NewtonMinimizer.cs b/src/Numerics/Optimization/NewtonMinimizer.cs index 5f17d738..8d399122 100644 --- a/src/Numerics/Optimization/NewtonMinimizer.cs +++ b/src/Numerics/Optimization/NewtonMinimizer.cs @@ -1,10 +1,7 @@ using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; using MathNet.Numerics.LinearAlgebra; -using LU = MathNet.Numerics.LinearAlgebra.Factorization.LU; using MathNet.Numerics.Optimization.Implementation; +using LU = MathNet.Numerics.LinearAlgebra.Factorization.LU; namespace MathNet.Numerics.Optimization { @@ -14,14 +11,14 @@ namespace MathNet.Numerics.Optimization public int MaximumIterations { get; set; } public bool UseLineSearch { get; set; } - public NewtonMinimizer(double gradient_tolerance, int maximum_iterations, bool use_line_search = false) + public NewtonMinimizer(double gradientTolerance, int maximumIterations, bool useLineSearch = false) { - this.GradientTolerance = gradient_tolerance; - this.MaximumIterations = maximum_iterations; - this.UseLineSearch = use_line_search; + GradientTolerance = gradientTolerance; + MaximumIterations = maximumIterations; + UseLineSearch = useLineSearch; } - public MinimizationOutput FindMinimum(IEvaluation objective, Vector initial_guess) + public MinimizationOutput FindMinimum(IEvaluation objective, Vector initialGuess) { if (!objective.GradientSupported) throw new IncompatibleObjectiveException("Gradient not supported in objective function, but required for Newton minimization."); @@ -30,74 +27,69 @@ namespace MathNet.Numerics.Optimization throw new IncompatibleObjectiveException("Hessian not supported in objective function, but required for Newton minimization."); if (!(objective is CheckedEvaluation)) - objective = new CheckedEvaluation(objective, this.ValidateObjective, this.ValidateGradient, this.ValidateHessian); + objective = new CheckedEvaluation(objective, ValidateObjective, ValidateGradient, ValidateHessian); - IEvaluation initial_eval = objective.CreateNew(); - initial_eval.Point = initial_guess; + IEvaluation initialEval = objective.CreateNew(); + initialEval.Point = initialGuess; // Check that we're not already done - if (this.ExitCriteriaSatisfied(initial_guess, initial_eval.Gradient)) - return new MinimizationOutput(initial_eval, 0, MinimizationOutput.ExitCondition.AbsoluteGradient); + if (ExitCriteriaSatisfied(initialGuess, initialEval.Gradient)) + return new MinimizationOutput(initialEval, 0, MinimizationOutput.ExitCondition.AbsoluteGradient); - // Set up line search algorithm - var line_searcher = new WeakWolfeLineSearch(1e-4, 0.9, 1e-4, max_iterations: 1000); + // Set up line search algorithm + var lineSearcher = new WeakWolfeLineSearch(1e-4, 0.9, 1e-4, maxIterations: 1000); // Declare state variables - IEvaluation candidate_point = initial_eval; - Vector search_direction; - LineSearchOutput result; + IEvaluation candidatePoint = initialEval; // Subsequent steps int iterations = 0; - int total_line_search_steps = 0; - int iterations_with_nontrivial_line_search = 0; - int steepest_descent_resets = 0; - bool tmp_line_search = false; - while (!this.ExitCriteriaSatisfied(candidate_point.Point, candidate_point.Gradient) && iterations < this.MaximumIterations) + int totalLineSearchSteps = 0; + int iterationsWithNontrivialLineSearch = 0; + bool tmpLineSearch = false; + while (!ExitCriteriaSatisfied(candidatePoint.Point, candidatePoint.Gradient) && iterations < MaximumIterations) { - - search_direction = candidate_point.Hessian.LU().Solve(-candidate_point.Gradient); - - if (search_direction * candidate_point.Gradient >= 0) + var searchDirection = candidatePoint.Hessian.LU().Solve(-candidatePoint.Gradient); + if (searchDirection * candidatePoint.Gradient >= 0) { - search_direction = -candidate_point.Gradient; - steepest_descent_resets += 1; - tmp_line_search = true; + searchDirection = -candidatePoint.Gradient; + tmpLineSearch = true; } - if (this.UseLineSearch || tmp_line_search) + if (UseLineSearch || tmpLineSearch) { + LineSearchOutput result; try { - result = line_searcher.FindConformingStep(objective, candidate_point, search_direction, 1.0); + result = lineSearcher.FindConformingStep(objective, candidatePoint, searchDirection, 1.0); } catch (Exception e) { throw new InnerOptimizationException("Line search failed.", e); } - iterations_with_nontrivial_line_search += result.Iterations > 0 ? 1 : 0; - total_line_search_steps += result.Iterations; - candidate_point = result.FunctionInfoAtMinimum; + iterationsWithNontrivialLineSearch += result.Iterations > 0 ? 1 : 0; + totalLineSearchSteps += result.Iterations; + candidatePoint = result.FunctionInfoAtMinimum; } else { - candidate_point.Point = candidate_point.Point + search_direction; + candidatePoint.Point = candidatePoint.Point + searchDirection; } - tmp_line_search = false; + tmpLineSearch = false; iterations += 1; } - if (iterations == this.MaximumIterations) - throw new MaximumIterationsException(String.Format("Maximum iterations ({0}) reached.", this.MaximumIterations)); + if (iterations == MaximumIterations) + throw new MaximumIterationsException(String.Format("Maximum iterations ({0}) reached.", MaximumIterations)); - return new MinimizationWithLineSearchOutput(candidate_point, iterations, MinimizationOutput.ExitCondition.AbsoluteGradient, total_line_search_steps, iterations_with_nontrivial_line_search); + return new MinimizationWithLineSearchOutput(candidatePoint, iterations, MinimizationOutput.ExitCondition.AbsoluteGradient, totalLineSearchSteps, iterationsWithNontrivialLineSearch); } - private bool ExitCriteriaSatisfied(Vector candidate_point, Vector gradient) + private bool ExitCriteriaSatisfied(Vector candidatePoint, Vector gradient) { - return gradient.Norm(2.0) < this.GradientTolerance; + return gradient.Norm(2.0) < GradientTolerance; } private void ValidateGradient(IEvaluation eval) diff --git a/src/UnitTests/OptimizationTests/TestNewtonMinimizer.cs b/src/UnitTests/OptimizationTests/TestNewtonMinimizer.cs index 2fbca71e..de23f090 100644 --- a/src/UnitTests/OptimizationTests/TestNewtonMinimizer.cs +++ b/src/UnitTests/OptimizationTests/TestNewtonMinimizer.cs @@ -14,17 +14,17 @@ namespace MathNet.Numerics.UnitTests.OptimizationTests public RosenbrockEvaluation() : base(true, true) { } - protected override void setValue() + protected override void SetValue() { this.ValueRaw = RosenbrockFunction.Value(this.Point); } - protected override void setGradient() + protected override void SetGradient() { this.GradientRaw = RosenbrockFunction.Gradient(this.Point); } - protected override void setHessian() + protected override void SetHessian() { this.HessianRaw = RosenbrockFunction.Hessian(this.Point); }