diff --git a/src/duneevaluate.cc b/src/duneevaluate.cc
index 6f4d90595253deff22981877bb14f0ba08fd524d..aa97d4e9177a1000f565042aed73df1695c2b790 100644
--- a/src/duneevaluate.cc
+++ b/src/duneevaluate.cc
@@ -20,21 +20,21 @@ Evaluate x -> 1/2<Ax,x> - <b,x> + H(|x|) at y using DUNE\n") {
   int const dim = 2;
 
   // {{{ The usual setup
-  typedef Dune::SampleFunctional<dim> SampleFunctional;
-  SampleFunctional::SmallMatrix A;
+  typedef Dune::SampleFunctional<dim> Functional;
+  Functional::SmallMatrix A;
   A[0][0] = 3;
   A[0][1] = 1.5;
   A[1][0] = 1.5;
   A[1][1] = 4;
-  SampleFunctional::SmallVector b;
+  Functional::SmallVector b;
   b[0] = 1;
   b[1] = 2;
 
   Dune::SampleFunction f;
-  SampleFunctional J(A, b, Dune::MyNonlinearity<dim>(f));
+  Functional J(A, b, Dune::MyNonlinearity<dim>(f));
   // }}}
 
-  SampleFunctional::SmallVector our_point;
+  Functional::SmallVector our_point;
   Dune::octaveToDune<dim>(point, our_point);
   return octave_value(J(our_point));
 }
diff --git a/src/duneminimise.cc b/src/duneminimise.cc
index 7b8b3bd384fb1499f890f9a95ba531f61fd66680..dc0d05a368502098799a60f25bfcc63174e7ed55 100644
--- a/src/duneminimise.cc
+++ b/src/duneminimise.cc
@@ -20,24 +20,24 @@ Make a minimisation step of x -> 1/2<Ax,x> - <b,x> + H(|x|) using DUNE starting
   int const dim = 2;
 
   // {{{ The usual setup
-  typedef Dune::SampleFunctional<dim> SampleFunctional;
-  SampleFunctional::SmallMatrix A;
+  typedef Dune::SampleFunctional<dim> Functional;
+  Functional::SmallMatrix A;
   A[0][0] = 3;
   A[0][1] = 1.5;
   A[1][0] = 1.5;
   A[1][1] = 4;
-  SampleFunctional::SmallVector b;
+  Functional::SmallVector b;
   b[0] = 1;
   b[1] = 2;
 
   Dune::SampleFunction f;
-  SampleFunctional J(A, b, Dune::MyNonlinearity<dim>(f));
+  Functional J(A, b, Dune::MyNonlinearity<dim>(f));
   // }}}
 
-  SampleFunctional::SmallVector start;
+  Functional::SmallVector start;
   Dune::octaveToDune<dim>(current, start);
 
-  SampleFunctional::SmallVector correction;
+  Functional::SmallVector correction;
   Dune::minimise(J, start, correction);
 
   ColumnVector ret(dim);
diff --git a/src/test-gradient-method.cc b/src/test-gradient-method.cc
index 3801344c59c6b7fe3a3598f91b02fe22104730f8..6b78d325ec37c800adb099bd92de371d10151e8e 100644
--- a/src/test-gradient-method.cc
+++ b/src/test-gradient-method.cc
@@ -30,21 +30,21 @@ double functionTester(Dune::SampleFunctional<dim> J,
 
 void testSampleFunction() {
   int const dim = 2;
-  typedef Dune::SampleFunctional<dim> SampleFunctional;
+  typedef Dune::SampleFunctional<dim> Functional;
 
-  SampleFunctional::SmallMatrix A;
+  Functional::SmallMatrix A;
   A[0][0] = 3;
   A[0][1] = 1.5;
   A[1][0] = 1.5;
   A[1][1] = 4;
-  SampleFunctional::SmallVector b;
+  Functional::SmallVector b;
   b[0] = 1;
   b[1] = 2;
 
   Dune::SampleFunction f;
-  SampleFunctional J(A, b, Dune::MyNonlinearity<dim>(f));
+  Functional J(A, b, Dune::MyNonlinearity<dim>(f));
 
-  SampleFunctional::SmallVector start = b;
+  Functional::SmallVector start = b;
   start *= 17;
 
   /*
@@ -53,10 +53,10 @@ void testSampleFunction() {
     = 17*(6, 9.5) - (1, 2) + 2/sqrt(5) (1, 2)
     = (102 - 1 + 2/sqrt(5), 161.5 - 2 + 4/sqrt(5))
   */
-  SampleFunctional::SmallVector error;
+  Functional::SmallVector error;
   error[0] = -(102 - 1 + 2 / sqrt(5));
   error[1] = -(161.5 - 2 + 4 / sqrt(5));
-  SampleFunctional::SmallVector returned;
+  Functional::SmallVector returned;
   J.descentDirection(start, returned);
   error -= returned;
   assert(error.two_norm() < 1e-10); // FIXME: 1e-10 sounds reasonable. Is it?
@@ -79,22 +79,22 @@ void testSampleFunction() {
 
 void testSampleFunctionNonsmooth() {
   int const dim = 2;
-  typedef Dune::SampleFunctional<dim> SampleFunctional;
+  typedef Dune::SampleFunctional<dim> Functional;
 
-  SampleFunctional::SmallMatrix A;
+  Functional::SmallMatrix A;
   A[0][0] = 3;
   A[0][1] = 1.5;
   A[1][0] = 1.5;
   A[1][1] = 4;
-  SampleFunctional::SmallVector b;
+  Functional::SmallVector b;
   b[0] = 1;
   b[1] = 2;
 
   Dune::SampleFunction f;
-  SampleFunctional J(A, b, Dune::MyNonlinearity<dim>(f));
+  Functional J(A, b, Dune::MyNonlinearity<dim>(f));
 
-  SampleFunctional::SmallVector start;
-  SampleFunctional::SmallVector error;
+  Functional::SmallVector start;
+  Functional::SmallVector error;
   /*
     for x = b/|b|:
 
@@ -113,7 +113,7 @@ void testSampleFunctionNonsmooth() {
     start /= (b.two_norm() + 1e-12);
     assert(start.two_norm() < 1);
 
-    SampleFunctional::SmallVector returned;
+    Functional::SmallVector returned;
     J.descentDirection(start, returned);
     error[0] = -(7 / sqrt(5) - 1);
     error[1] = -(11.5 / sqrt(5) - 2);
@@ -128,7 +128,7 @@ void testSampleFunctionNonsmooth() {
     start /= (b.two_norm() - 1e-12); // Make sure the norm is above 1;
     assert(start.two_norm() > 1);
 
-    SampleFunctional::SmallVector returned;
+    Functional::SmallVector returned;
     J.descentDirection(start, returned);
     error[0] = -(8 / sqrt(5) - 1);
     error[1] = -(13.5 / sqrt(5) - 2);
@@ -141,21 +141,21 @@ void testSampleFunctionNonsmooth() {
 
 void testTrivialFunction() {
   int const dim = 2;
-  typedef Dune::SampleFunctional<dim> SampleFunctional;
+  typedef Dune::SampleFunctional<dim> Functional;
 
-  SampleFunctional::SmallMatrix A;
+  Functional::SmallMatrix A;
   A[0][0] = 3;
   A[0][1] = 1.5;
   A[1][0] = 1.5;
   A[1][1] = 4;
-  SampleFunctional::SmallVector b;
+  Functional::SmallVector b;
   b[0] = 1;
   b[1] = 2;
 
   Dune::TrivialFunction f;
-  SampleFunctional J(A, b, Dune::MyNonlinearity<dim>(f));
+  Functional J(A, b, Dune::MyNonlinearity<dim>(f));
 
-  SampleFunctional::SmallVector start = b;
+  Functional::SmallVector start = b;
   start *= 17;
 
   /*
@@ -164,10 +164,10 @@ void testTrivialFunction() {
     = 17*(6, 9.5) - (1, 2)
     = (102 - 1, 161.5 - 2)
   */
-  SampleFunctional::SmallVector error;
+  Functional::SmallVector error;
   error[0] = -101;
   error[1] = -159.5;
-  SampleFunctional::SmallVector returned;
+  Functional::SmallVector returned;
   J.descentDirection(start, returned);
   error -= returned;
   assert(error.two_norm() < 1e-10); // FIXME: 1e-10 sounds reasonable. Is it?
@@ -185,21 +185,21 @@ void testTrivialFunction() {
 
 void testHorribleFunction() {
   int const dim = 2;
-  typedef Dune::SampleFunctional<dim> SampleFunctional;
+  typedef Dune::SampleFunctional<dim> Functional;
 
-  SampleFunctional::SmallMatrix A;
+  Functional::SmallMatrix A;
   A[0][0] = 3;
   A[0][1] = 1.5;
   A[1][0] = 1.5;
   A[1][1] = 4;
-  SampleFunctional::SmallVector b;
+  Functional::SmallVector b;
   b[0] = 1;
   b[1] = 2;
 
   Dune::HorribleFunction f;
-  SampleFunctional J(A, b, Dune::MyNonlinearity<dim>(f));
+  Functional J(A, b, Dune::MyNonlinearity<dim>(f));
 
-  SampleFunctional::SmallVector start = b;
+  Functional::SmallVector start = b;
   start *= 17;
 
   double const ret1 = functionTester(J, start, 7);
@@ -220,21 +220,21 @@ void testHorribleFunction() {
 
 void testHorribleFunctionLogarithmic() {
   int const dim = 2;
-  typedef Dune::SampleFunctional<dim> SampleFunctional;
+  typedef Dune::SampleFunctional<dim> Functional;
 
-  SampleFunctional::SmallMatrix A;
+  Functional::SmallMatrix A;
   A[0][0] = 3;
   A[0][1] = 1.5;
   A[1][0] = 1.5;
   A[1][1] = 4;
-  SampleFunctional::SmallVector b;
+  Functional::SmallVector b;
   b[0] = 1;
   b[1] = 2;
 
   Dune::HorribleFunctionLogarithmic f;
-  SampleFunctional J(A, b, Dune::MyNonlinearity<dim>(f));
+  Functional J(A, b, Dune::MyNonlinearity<dim>(f));
 
-  SampleFunctional::SmallVector start = b;
+  Functional::SmallVector start = b;
   start *= 17;
 
   double const ret1 = functionTester(J, start, 6);