Convert tests.

diff --git a/tests/sundials/kinsol_01.cc b/tests/sundials/kinsol_01.cc
index 9224bdf42332fd7a118210e6cf31a015bee05292..7d5623e2424c59a577b7ca3669e56aeb9de2f0c8 100644 (file)
--- a/tests/sundials/kinsol_01.cc
+++ b/tests/sundials/kinsol_01.cc
@@ -61,7 +61,7 @@ main()
   kinsol.reinit_vector = [N](VectorType &v) { v.reinit(N); };
 
   // Robert example
-  kinsol.iteration_function = [](const VectorType &u, VectorType &F) -> int {
+  kinsol.iteration_function = [](const VectorType &u, VectorType &F) {
     const double dstep = 0.1;
     const double y10   = 1.0;
     const double y20   = 0.0;
@@ -73,8 +73,6 @@ main()
     F[0] = yd1 + y10;
     F[1] = -yd1 - yd3 + y20;
     F[2] = yd3 + y30;
-
-    return 0;
   };
 
   VectorType v(N);

diff --git a/tests/sundials/kinsol_02.cc b/tests/sundials/kinsol_02.cc
index 5c8574a767c69c1d3534d5b9e58335540d83c477..fc5e214b205f905511e021f166efff68795eae68 100644 (file)
--- a/tests/sundials/kinsol_02.cc
+++ b/tests/sundials/kinsol_02.cc
@@ -63,27 +63,20 @@ main()
 
   kinsol.reinit_vector = [N](VectorType &v) { v.reinit(N); };
 
-  kinsol.residual = [&](const VectorType &u, VectorType &F) -> int {
+  kinsol.residual = [&](const VectorType &u, VectorType &F) {
     F = u;
 
     F[0] += .1 * u[0] * u[0] - 1;
     F[1] += .1 * u[1] * u[1] - 2;
-    return 0;
   };
 
   kinsol.solve_with_jacobian =
-    [&](const VectorType &rhs, VectorType &dst, double) -> int {
-    dst = rhs;
-    return 0;
-  };
+    [&](const VectorType &rhs, VectorType &dst, double) { dst = rhs; };
 
   kinsol.solve_jacobian_system = [&](const VectorType &,
                                      const VectorType &,
                                      const VectorType &rhs,
-                                     VectorType &      dst) -> int {
-    dst = rhs;
-    return 0;
-  };
+                                     VectorType &      dst) { dst = rhs; };
 
   VectorType v(N);
 

diff --git a/tests/sundials/kinsol_03.cc b/tests/sundials/kinsol_03.cc
index e90968e733aae1b4b6ec512d0f37a23d37c1ba82..f0af240a1ef9f17949ace0fd35e9fb7b7ba63168 100644 (file)
--- a/tests/sundials/kinsol_03.cc
+++ b/tests/sundials/kinsol_03.cc
@@ -65,17 +65,16 @@ main()
 
   kinsol.reinit_vector = [N](VectorType &v) { v.reinit(N); };
 
-  kinsol.residual = [](const VectorType &u, VectorType &F) -> int {
+  kinsol.residual = [](const VectorType &u, VectorType &F) {
     deallog << "Evaluating the solution at u=(" << u[0] << ',' << u[1] << ')'
             << std::endl;
 
     F(0) = std::cos(u[0] + u[1]) - 1 + 2 * u[0];
     F(1) = std::sin(u[0] - u[1]) + 2 * u[1];
-    return 0;
   };
 
 
-  kinsol.iteration_function = [](const VectorType &u, VectorType &F) -> int {
+  kinsol.iteration_function = [](const VectorType &u, VectorType &F) {
     // We want a Newton-type scheme, not a fixed point iteration. So we
     // shouldn't get into this function.
     std::abort();
@@ -83,23 +82,21 @@ main()
     // But if anyone wanted to see how it would look like:
     F(0) = std::cos(u[0] + u[1]) - 1 + 2 * u[0] - u[0];
     F(1) = std::sin(u[0] - u[1]) + 2 * u[1] - u[1];
-    return 0;
   };
 
 
-  kinsol.setup_jacobian = [](const VectorType &u, const VectorType &F) -> int {
+  kinsol.setup_jacobian = [](const VectorType &u, const VectorType &F) {
     // We don't do any kind of set-up in this program, but we can at least
     // say that we're here
     deallog << "Setting up Jacobian system at u=(" << u[0] << ',' << u[1] << ')'
             << std::endl;
-    return 0;
   };
 
 
   kinsol.solve_jacobian_system = [](const VectorType &,
                                     const VectorType &,
                                     const VectorType &rhs,
-                                    VectorType &      dst) -> int {
+                                    VectorType &      dst) {
     deallog << "Solving Jacobian system with rhs=(" << rhs[0] << ',' << rhs[1]
             << ')' << std::endl;
 
@@ -120,8 +117,6 @@ main()
     J_inverse.invert(J);
 
     J_inverse.vmult(dst, rhs);
-
-    return 0;
   };
 
   VectorType v(N);

diff --git a/tests/sundials/kinsol_03_new_interface.cc b/tests/sundials/kinsol_03_new_interface.cc
index 11ab7f3c502ab29168fa5ee88763741bd1a390d3..86ccd311192c933b819494260f94324c30a5f7b8 100644 (file)
--- a/tests/sundials/kinsol_03_new_interface.cc
+++ b/tests/sundials/kinsol_03_new_interface.cc
@@ -65,17 +65,16 @@ main()
 
   kinsol.reinit_vector = [N](VectorType &v) { v.reinit(N); };
 
-  kinsol.residual = [](const VectorType &u, VectorType &F) -> int {
+  kinsol.residual = [](const VectorType &u, VectorType &F) {
     deallog << "Evaluating the solution at u=(" << u[0] << ',' << u[1] << ')'
             << std::endl;
 
     F(0) = std::cos(u[0] + u[1]) - 1 + 2 * u[0];
     F(1) = std::sin(u[0] - u[1]) + 2 * u[1];
-    return 0;
   };
 
 
-  kinsol.iteration_function = [](const VectorType &u, VectorType &F) -> int {
+  kinsol.iteration_function = [](const VectorType &u, VectorType &F) {
     // We want a Newton-type scheme, not a fixed point iteration. So we
     // shouldn't get into this function.
     std::abort();
@@ -83,45 +82,40 @@ main()
     // But if anyone wanted to see how it would look like:
     F(0) = std::cos(u[0] + u[1]) - 1 + 2 * u[0] - u[0];
     F(1) = std::sin(u[0] - u[1]) + 2 * u[1] - u[1];
-    return 0;
   };
 
 
-  kinsol.setup_jacobian = [](const VectorType &u, const VectorType &F) -> int {
+  kinsol.setup_jacobian = [](const VectorType &u, const VectorType &F) {
     // We don't do any kind of set-up in this program, but we can at least
     // say that we're here
     deallog << "Setting up Jacobian system at u=(" << u[0] << ',' << u[1] << ')'
             << std::endl;
-    return 0;
   };
 
 
-  kinsol.solve_with_jacobian = [](const VectorType &rhs,
-                                  VectorType &      dst,
-                                  const double /*tolerance*/) -> int {
-    deallog << "Solving Jacobian system with rhs=(" << rhs[0] << ',' << rhs[1]
-            << ')' << std::endl;
+  kinsol.solve_with_jacobian =
+    [](const VectorType &rhs, VectorType &dst, const double /*tolerance*/) {
+      deallog << "Solving Jacobian system with rhs=(" << rhs[0] << ',' << rhs[1]
+              << ')' << std::endl;
 
-    // This isn't right for SUNDIALS >4.0: We don't actually get a valid
-    // 'u' vector, and so do the linearization of the problem around
-    // the zero vector. This *happens* to converge, but it isn't the
-    // right approach. Check the _04 test for a better approach.
-    VectorType u(2);
-    u[0] = u[1] = 0;
+      // This isn't right for SUNDIALS >4.0: We don't actually get a valid
+      // 'u' vector, and so do the linearization of the problem around
+      // the zero vector. This *happens* to converge, but it isn't the
+      // right approach. Check the _04 test for a better approach.
+      VectorType u(2);
+      u[0] = u[1] = 0;
 
-    FullMatrix<double> J(2, 2);
-    J(0, 0) = -std::sin(u[0] + u[1]) + 2;
-    J(0, 1) = -std::sin(u[0] + u[1]);
-    J(1, 0) = std::cos(u[0] - u[1]);
-    J(1, 1) = -std::cos(u[0] - u[1]) + 2;
+      FullMatrix<double> J(2, 2);
+      J(0, 0) = -std::sin(u[0] + u[1]) + 2;
+      J(0, 1) = -std::sin(u[0] + u[1]);
+      J(1, 0) = std::cos(u[0] - u[1]);
+      J(1, 1) = -std::cos(u[0] - u[1]) + 2;
 
-    FullMatrix<double> J_inverse(2, 2);
-    J_inverse.invert(J);
+      FullMatrix<double> J_inverse(2, 2);
+      J_inverse.invert(J);
 
-    J_inverse.vmult(dst, rhs);
-
-    return 0;
-  };
+      J_inverse.vmult(dst, rhs);
+    };
 
   VectorType v(N);
   v(0) = 0.5;

diff --git a/tests/sundials/kinsol_04.cc b/tests/sundials/kinsol_04.cc
index a499ad1afc9f27d30221a39826a7922a2ee09776..429658f652cbcd4bebe9ed46c2de2ae2a4436775 100644 (file)
--- a/tests/sundials/kinsol_04.cc
+++ b/tests/sundials/kinsol_04.cc
@@ -77,17 +77,16 @@ main()
 
   kinsol.reinit_vector = [N](VectorType &v) { v.reinit(N); };
 
-  kinsol.residual = [](const VectorType &u, VectorType &F) -> int {
+  kinsol.residual = [](const VectorType &u, VectorType &F) {
     deallog << "Evaluating the solution at u=(" << u[0] << ',' << u[1] << ')'
             << std::endl;
 
     F(0) = std::cos(u[0] + u[1]) - 1 + 2 * u[0];
     F(1) = std::sin(u[0] - u[1]) + 2 * u[1];
-    return 0;
   };
 
 
-  kinsol.iteration_function = [](const VectorType &u, VectorType &F) -> int {
+  kinsol.iteration_function = [](const VectorType &u, VectorType &F) {
     // We want a Newton-type scheme, not a fixed point iteration. So we
     // shouldn't get into this function.
     std::abort();
@@ -95,13 +94,12 @@ main()
     // But if anyone wanted to see how it would look like:
     F(0) = std::cos(u[0] + u[1]) - 1 + 2 * u[0] - u[0];
     F(1) = std::sin(u[0] - u[1]) + 2 * u[1] - u[1];
-    return 0;
   };
 
   FullMatrix<double> J_inverse(2, 2);
 
   kinsol.setup_jacobian = [&J_inverse](const VectorType &u,
-                                       const VectorType &F) -> int {
+                                       const VectorType &F) {
     deallog << "Setting up Jacobian system at u=(" << u[0] << ',' << u[1] << ')'
             << std::endl;
 
@@ -112,21 +110,17 @@ main()
     J(1, 1) = -std::cos(u[0] - u[1]) + 2;
 
     J_inverse.invert(J);
-
-    return 0;
   };
 
 
   kinsol.solve_jacobian_system = [&J_inverse](const VectorType &u,
                                               const VectorType &,
                                               const VectorType &rhs,
-                                              VectorType &      dst) -> int {
+                                              VectorType &      dst) {
     deallog << "Solving Jacobian system with rhs=(" << rhs[0] << ',' << rhs[1]
             << ')' << std::endl;
 
     J_inverse.vmult(dst, rhs);
-
-    return 0;
   };
 
   VectorType v(N);

diff --git a/tests/sundials/kinsol_04_new_interface.cc b/tests/sundials/kinsol_04_new_interface.cc
index f4435d791180b33234097f77c84c44d1e2d59b92..a2fe0f3e0ecf38fe46127f46f988693f216df514 100644 (file)
--- a/tests/sundials/kinsol_04_new_interface.cc
+++ b/tests/sundials/kinsol_04_new_interface.cc
@@ -77,17 +77,16 @@ main()
 
   kinsol.reinit_vector = [N](VectorType &v) { v.reinit(N); };
 
-  kinsol.residual = [](const VectorType &u, VectorType &F) -> int {
+  kinsol.residual = [](const VectorType &u, VectorType &F) {
     deallog << "Evaluating the solution at u=(" << u[0] << ',' << u[1] << ')'
             << std::endl;
 
     F(0) = std::cos(u[0] + u[1]) - 1 + 2 * u[0];
     F(1) = std::sin(u[0] - u[1]) + 2 * u[1];
-    return 0;
   };
 
 
-  kinsol.iteration_function = [](const VectorType &u, VectorType &F) -> int {
+  kinsol.iteration_function = [](const VectorType &u, VectorType &F) {
     // We want a Newton-type scheme, not a fixed point iteration. So we
     // shouldn't get into this function.
     std::abort();
@@ -95,13 +94,12 @@ main()
     // But if anyone wanted to see how it would look like:
     F(0) = std::cos(u[0] + u[1]) - 1 + 2 * u[0] - u[0];
     F(1) = std::sin(u[0] - u[1]) + 2 * u[1] - u[1];
-    return 0;
   };
 
   FullMatrix<double> J_inverse(2, 2);
 
   kinsol.setup_jacobian = [&J_inverse](const VectorType &u,
-                                       const VectorType &F) -> int {
+                                       const VectorType &F) {
     deallog << "Setting up Jacobian system at u=(" << u[0] << ',' << u[1] << ')'
             << std::endl;
 
@@ -112,20 +110,16 @@ main()
     J(1, 1) = -std::cos(u[0] - u[1]) + 2;
 
     J_inverse.invert(J);
-
-    return 0;
   };
 
 
   kinsol.solve_with_jacobian = [&J_inverse](const VectorType &rhs,
                                             VectorType &      dst,
-                                            const double /*tolerance*/) -> int {
+                                            const double /*tolerance*/) {
     deallog << "Solving Jacobian system with rhs=(" << rhs[0] << ',' << rhs[1]
             << ')' << std::endl;
 
     J_inverse.vmult(dst, rhs);
-
-    return 0;
   };
 
   VectorType v(N);

diff --git a/tests/sundials/kinsol_05.cc b/tests/sundials/kinsol_05.cc
index 9e8f2046e5da7e218269937bc268c7edf03aff61..b35068108e22dd3fa3373fbe3a9b98d2eef85e79 100644 (file)
--- a/tests/sundials/kinsol_05.cc
+++ b/tests/sundials/kinsol_05.cc
@@ -75,17 +75,16 @@ main()
 
   kinsol.reinit_vector = [N](VectorType &v) { v.reinit(N); };
 
-  kinsol.residual = [](const VectorType &u, VectorType &F) -> int {
+  kinsol.residual = [](const VectorType &u, VectorType &F) {
     deallog << "Evaluating the solution at u=(" << u[0] << ',' << u[1] << ')'
             << std::endl;
 
     F(0) = std::cos(u[0] + u[1]) - 1 + 2 * u[0];
     F(1) = std::sin(u[0] - u[1]) + 2 * u[1];
-    return 0;
   };
 
 
-  kinsol.iteration_function = [](const VectorType &u, VectorType &F) -> int {
+  kinsol.iteration_function = [](const VectorType &u, VectorType &F) {
     // We want a Newton-type scheme, not a fixed point iteration. So we
     // shouldn't get into this function.
     std::abort();
@@ -93,13 +92,12 @@ main()
     // But if anyone wanted to see how it would look like:
     F(0) = std::cos(u[0] + u[1]) - 1 + 2 * u[0] - u[0];
     F(1) = std::sin(u[0] - u[1]) + 2 * u[1] - u[1];
-    return 0;
   };
 
   FullMatrix<double> J_inverse(2, 2);
 
   kinsol.setup_jacobian = [&J_inverse](const VectorType &u,
-                                       const VectorType &F) -> int {
+                                       const VectorType &F) {
     // We don't do any kind of set-up in this program, but we can at least
     // say that we're here
     deallog << "Setting up Jacobian system at u=(" << u[0] << ',' << u[1] << ')'
@@ -112,21 +110,17 @@ main()
     J(1, 1) = -std::cos(u[0] - u[1]) + 2;
 
     J_inverse.invert(J);
-
-    return 0;
   };
 
 
   kinsol.solve_jacobian_system = [&J_inverse](const VectorType &u,
                                               const VectorType &,
                                               const VectorType &rhs,
-                                              VectorType &      dst) -> int {
+                                              VectorType &      dst) {
     deallog << "Solving Jacobian system with rhs=(" << rhs[0] << ',' << rhs[1]
             << ')' << std::endl;
 
     J_inverse.vmult(dst, rhs);
-
-    return 0;
   };
 
   VectorType v(N);

diff --git a/tests/sundials/kinsol_05_new_interface.cc b/tests/sundials/kinsol_05_new_interface.cc
index 09d40c03c76abaa50980985b1e2ed4aea2dd65d0..facf645aa8837113a52e00265eac28acd4069909 100644 (file)
--- a/tests/sundials/kinsol_05_new_interface.cc
+++ b/tests/sundials/kinsol_05_new_interface.cc
@@ -75,17 +75,16 @@ main()
 
   kinsol.reinit_vector = [N](VectorType &v) { v.reinit(N); };
 
-  kinsol.residual = [](const VectorType &u, VectorType &F) -> int {
+  kinsol.residual = [](const VectorType &u, VectorType &F) {
     deallog << "Evaluating the solution at u=(" << u[0] << ',' << u[1] << ')'
             << std::endl;
 
     F(0) = std::cos(u[0] + u[1]) - 1 + 2 * u[0];
     F(1) = std::sin(u[0] - u[1]) + 2 * u[1];
-    return 0;
   };
 
 
-  kinsol.iteration_function = [](const VectorType &u, VectorType &F) -> int {
+  kinsol.iteration_function = [](const VectorType &u, VectorType &F) {
     // We want a Newton-type scheme, not a fixed point iteration. So we
     // shouldn't get into this function.
     std::abort();
@@ -93,13 +92,12 @@ main()
     // But if anyone wanted to see how it would look like:
     F(0) = std::cos(u[0] + u[1]) - 1 + 2 * u[0] - u[0];
     F(1) = std::sin(u[0] - u[1]) + 2 * u[1] - u[1];
-    return 0;
   };
 
   FullMatrix<double> J_inverse(2, 2);
 
   kinsol.setup_jacobian = [&J_inverse](const VectorType &u,
-                                       const VectorType &F) -> int {
+                                       const VectorType &F) {
     // We don't do any kind of set-up in this program, but we can at least
     // say that we're here
     deallog << "Setting up Jacobian system at u=(" << u[0] << ',' << u[1] << ')'
@@ -112,20 +110,16 @@ main()
     J(1, 1) = -std::cos(u[0] - u[1]) + 2;
 
     J_inverse.invert(J);
-
-    return 0;
   };
 
 
   kinsol.solve_with_jacobian = [&J_inverse](const VectorType &rhs,
                                             VectorType &      dst,
-                                            const double /*tolerance*/) -> int {
+                                            const double /*tolerance*/) {
     deallog << "Solving Jacobian system with rhs=(" << rhs[0] << ',' << rhs[1]
             << ')' << std::endl;
 
     J_inverse.vmult(dst, rhs);
-
-    return 0;
   };
 
   VectorType v(N);

diff --git a/tests/sundials/kinsol_06.cc b/tests/sundials/kinsol_06.cc
index 359dff96b2fc9db37f7c0ec181d2ab2135f15e0b..917a4546db470fb62ee7ea48c1da36760c868a88 100644 (file)
--- a/tests/sundials/kinsol_06.cc
+++ b/tests/sundials/kinsol_06.cc
@@ -60,40 +60,34 @@ main()
 
   kinsol.reinit_vector = [N](VectorType &v) { v.reinit(N); };
 
-  kinsol.residual = [&](const VectorType &u, VectorType &F) -> int {
+  kinsol.residual = [&](const VectorType &u, VectorType &F) {
     deallog << "Computing residual at " << u[0] << std::endl;
 
     if ((u[0] < -10) || (u[0] > 20))
       {
         deallog << "Reporting recoverable failure." << std::endl;
-        return 1;
+        throw RecoverableUserCallbackError();
       }
 
 
     F.reinit(u);
     F[0] = std::atan(u[0]) - 0.5;
-
-    return 0;
   };
 
   double J_inverse;
 
   kinsol.setup_jacobian = [&J_inverse](const VectorType &u,
-                                       const VectorType &F) -> int {
+                                       const VectorType &F) {
     deallog << "Setting up Jacobian system at u=" << u[0] << std::endl;
 
     const double J = 1. / (1 + u[0] * u[0]);
     J_inverse      = 1. / J;
-
-    return 0;
   };
 
 
-  kinsol.solve_with_jacobian =
-    [&](const VectorType &rhs, VectorType &dst, double) -> int {
-    dst[0] = J_inverse * rhs[0];
-    return 0;
-  };
+  kinsol.solve_with_jacobian = [&](const VectorType &rhs,
+                                   VectorType &      dst,
+                                   double) { dst[0] = J_inverse * rhs[0]; };
 
   VectorType v(N);
   v[0] = 10;

diff --git a/tests/sundials/step-77.cc b/tests/sundials/step-77.cc
index 7585e58fb0d153821ce622759c47f1580a3ad688..4c427d2636854adcb0fc16923b4e2883198e631f 100644 (file)
--- a/tests/sundials/step-77.cc
+++ b/tests/sundials/step-77.cc
@@ -424,24 +424,18 @@ namespace Step77
             [&](const Vector<double> &evaluation_point,
                 Vector<double> &      residual) {
               compute_residual(evaluation_point, residual);
-
-              return 0;
             };
 
           nonlinear_solver.setup_jacobian =
             [&](const Vector<double> &current_u,
                 const Vector<double> & /*current_f*/) {
               compute_and_factorize_jacobian(current_u);
-
-              return 0;
             };
 
           nonlinear_solver.solve_with_jacobian = [&](const Vector<double> &rhs,
                                                      Vector<double> &      dst,
                                                      const double tolerance) {
             this->solve(rhs, dst, tolerance);
-
-            return 0;
           };
 
           nonlinear_solver.solve(current_solution);
@@ -461,5 +455,4 @@ main()
 
   MinimalSurfaceProblem<2> laplace_problem_2d;
   laplace_problem_2d.run();
-  return 0;
 }