Modularise minimise()

dune/tectonic/samplefunctional.hh

@@ -134,25 +134,18 @@ template <int dim> class SampleFunctional {
 };
 
 template <class Functional>
-void minimise(Functional const &J, typename Functional::SmallVector &x,
-              size_t steps, Bisection const &bisection) {
+void descentMinimisation(Functional const &J,
+                         typename Functional::SmallVector &x,
+                         typename Functional::SmallVector const &descDir,
+                         Bisection const &bisection) {
   typedef typename Functional::SmallVector SmallVector;
-
-  for (size_t step = 0; step < steps; ++step) {
-    SmallVector descDir;
-    bool const linesearchp = J.descentDirection(x, descDir);
-
-    if (descDir == SmallVector(0.0))
-      return;
-
   typedef typename Functional::NonlinearityType LocalNonlinearityType;
-    if (linesearchp) {
+
   // {{{ Construct a restriction of J to the line x + t * descDir
 
   /* We have
 
-         1/2 <A(u+xv),u+xv>-<b,u+xv> = 1/2 <Av,v> x^2 - <b-Au,v> x + <1/2
-         Au-b,u>
+     1/2 <A(u+xv),u+xv>-<b,u+xv> = 1/2 <Av,v> x^2 - <b-Au,v> x + <1/2 Au-b,u>
 
      since A is symmetric.
   */
@@ -171,9 +164,9 @@ void minimise(Functional const &J, typename Functional::SmallVector &x,
     Interval<double> D;
     JRest.subDiff(0, D);
 
-        dverb << "## Directional derivative (as per subdifferential of "
-                 "restriction): " << D[1] << " (coordinates of the restriction)"
-              << std::endl;
+    dverb
+        << "## Directional derivative (as per subdifferential of restriction): "
+        << D[1] << " (coordinates of the restriction)" << std::endl;
     /*
       It is possible that this differs quite a lot from the
       directional derivative computed in the descentDirection()
@@ -196,25 +189,51 @@ void minimise(Functional const &J, typename Functional::SmallVector &x,
   ;
 
   x.axpy(stepsize, descDir);
-    } else {
-      Bisection slowBisection(bisection);
-      slowBisection.setFastQuadratic(false);
+}
+
+template <class Functional>
+void tangentialMinimisation(Functional const &J,
+                            typename Functional::SmallVector &x,
+                            typename Functional::SmallVector const &descDir,
+                            Bisection const &bisection) {
+  typedef typename Functional::NonlinearityType LocalNonlinearityType;
+  typedef typename Functional::SmallVector SmallVector;
 
-      CircularConvexFunction<LocalNonlinearityType> const JRest(
-          J.A, J.b, *J.phi, x, descDir);
+  CircularConvexFunction<LocalNonlinearityType> const JRest(J.A, J.b, *J.phi, x,
+                                                            descDir);
 
   int count;
-      double const stepsize = slowBisection.minimize(JRest, 0.0, 1.0, count);
+  double const stepsize = bisection.minimize(JRest, 0.0, 1.0, count);
   dverb << "Number of iterations in the bisection method: " << count
         << std::endl;
   ;
 
-      // Since x is used in the computation of the rhs, do not write to it
-      // directly
+  // Since x is used in the computation of the rhs, do not write to it directly
   SmallVector tmp;
   JRest.cartesian(stepsize, tmp);
   x = tmp;
 }
+
+template <class Functional>
+void minimise(Functional const &J, typename Functional::SmallVector &x,
+              size_t steps, Bisection const &bisection) {
+  typedef typename Functional::SmallVector SmallVector;
+
+  for (size_t step = 0; step < steps; ++step) {
+    SmallVector descDir;
+    bool const linesearchp = J.descentDirection(x, descDir);
+
+    if (descDir == SmallVector(0.0))
+      return;
+
+    if (linesearchp) {
+      descentMinimisation(J, x, descDir, bisection);
+    } else {
+      Bisection slowBisection(bisection);
+      slowBisection.setFastQuadratic(false);
+
+      tangentialMinimisation(J, x, descDir, slowBisection);
+    }
   }
 }
 }