More VECTOR -> VectorType

diff --git a/tests/bits/fe_tools_common.h b/tests/bits/fe_tools_common.h
index 5707052333cdd38e502bbe3f8d4490898e478951..c0b5146015c3e736008bfdb0fbad8d03396f6110 100644 (file)
--- a/tests/bits/fe_tools_common.h
+++ b/tests/bits/fe_tools_common.h
@@ -76,17 +76,17 @@ output_matrix (const FullMatrix<double> &m)
 
 
 // output some indicators for a given vector
-template <class VECTOR>
+template <typename VectorType>
 void
-output_vector (const VECTOR &v)
+output_vector (const VectorType &v)
 {
   deallog << v.l1_norm() << ' ' << v.l2_norm() << ' ' << v.linfty_norm()
           << std::endl;
 
   // write out at most 20 equispaced
   // elements of the vector
-  for (unsigned int i=0; i<v.size(); i+=std::max(static_cast<typename VECTOR::size_type>(1),
-                                                 static_cast<typename VECTOR::size_type>(v.size()/20)))
+  for (unsigned int i=0; i<v.size(); i+=std::max(static_cast<typename VectorType::size_type>(1),
+                                                 static_cast<typename VectorType::size_type>(v.size()/20)))
     deallog << v(i) << ' ';
   deallog << std::endl;
 }

diff --git a/tests/gla/extract_subvector_to_parallel.cc b/tests/gla/extract_subvector_to_parallel.cc
index a231ba956fe03c41cee55accd03a5c7eb1d5d81b..0453cd94d3e3dacc72b6463167f54d33e4cb3aff 100644 (file)
--- a/tests/gla/extract_subvector_to_parallel.cc
+++ b/tests/gla/extract_subvector_to_parallel.cc
@@ -15,7 +15,7 @@
 
 
 
-// test the various VECTOR::extract_subvector_to functions for
+// test the various extract_subvector_to functions for
 // parallel vectors and block vectors
 
 #include "../tests.h"

diff --git a/tests/lac/filtered_matrix.cc b/tests/lac/filtered_matrix.cc
index 158a973dddbf94cb5b71d565b328e376ea64dc6e..593ecea22df37a34c3b779a4c3a80916da343c23 100644 (file)
--- a/tests/lac/filtered_matrix.cc
+++ b/tests/lac/filtered_matrix.cc
@@ -25,21 +25,21 @@
 #include <fstream>
 
 
-template<class VECTOR>
-void test (const FilteredMatrix<VECTOR> &M)
+template<typename VectorType>
+void test (const FilteredMatrix<VectorType> &M)
 {
   deallog << "Iterator";
 
   unsigned int max = 0;
-  for (typename FilteredMatrix<VECTOR>::const_iterator i= M.begin();
+  for (typename FilteredMatrix<VectorType>::const_iterator i= M.begin();
        i != M.end(); ++i)
     {
       Assert(i->row() == i->column(), ExcInternalError());
       deallog << ' ' << i->row() << ':' << i->value();
       max = i->row();
     }
-  VECTOR v(max+1);
-  VECTOR w(max+1);
+  VectorType v(max+1);
+  VectorType w(max+1);
 
   for (unsigned int i=0; i<v.size(); ++i)
     v(i) = 31+i;

diff --git a/tests/lac/linear_operator_08.cc b/tests/lac/linear_operator_08.cc
index 6ba3f68e7de732d4e225fb06fa37e8ae60bef806..d3c5526097f70cff2dc09f133c325667800fd513 100644 (file)
--- a/tests/lac/linear_operator_08.cc
+++ b/tests/lac/linear_operator_08.cc
@@ -49,38 +49,38 @@
 using namespace dealii;
 
 
-template<class PRECONDITIONER, class MATRIX, class VECTOR,
+template<class PRECONDITIONER, class MATRIX, typename VectorType,
          class ADDITIONAL_DATA = typename PRECONDITIONER::AdditionalData>
 void
 test_preconditioner (const MATRIX &A,
-                     const VECTOR &b,
+                     const VectorType &b,
                      const ADDITIONAL_DATA &data = ADDITIONAL_DATA())
 {
-  const auto lo_A = linear_operator<VECTOR>(A);
+  const auto lo_A = linear_operator<VectorType>(A);
 
   PRECONDITIONER preconditioner;
   preconditioner.initialize(A, data);
 
   SolverControl solver_control (100, 1.0e-10);
-  SolverCG<VECTOR> solver (solver_control);
+  SolverCG<VectorType> solver (solver_control);
 
   // Exact inverse
   const auto lo_A_inv = inverse_operator(lo_A,
                                          solver,
                                          preconditioner);
 
-  const VECTOR x = lo_A_inv*b;
+  const VectorType x = lo_A_inv*b;
 
   // Approximate inverse
   {
     // Using exemplar matrix
-    const auto lo_A_inv_approx = linear_operator<VECTOR>(A, preconditioner);
-    const VECTOR x_approx = lo_A_inv_approx*b;
+    const auto lo_A_inv_approx = linear_operator<VectorType>(A, preconditioner);
+    const VectorType x_approx = lo_A_inv_approx*b;
   }
   {
     // Stand-alone
-    const auto lo_A_inv_approx = linear_operator<VECTOR>(preconditioner);
-    const VECTOR x_approx = lo_A_inv_approx*b;
+    const auto lo_A_inv_approx = linear_operator<VectorType>(preconditioner);
+    const VectorType x_approx = lo_A_inv_approx*b;
   }
 }
 
@@ -193,16 +193,16 @@ public:
                               matrix.n_block_cols());
   }
 
-  template<typename VECTOR>
+  template<typename VectorType>
   void
-  vmult(VECTOR &dst, const VECTOR &src) const
+  vmult(VectorType &dst, const VectorType &src) const
   {
     dst = src;
   }
 
-  template<class VECTOR>
+  template<typename VectorType>
   void
-  Tvmult(VECTOR &dst, const VECTOR &src) const
+  Tvmult(VectorType &dst, const VectorType &src) const
   {
     dst = src;
   }

diff --git a/tests/lac/solver.cc b/tests/lac/solver.cc
index 8f3ece8434738157b5a3a8f503dc0529f26311de..b5da2d654162c33c93114a6440ce8783a908e197 100644 (file)
--- a/tests/lac/solver.cc
+++ b/tests/lac/solver.cc
@@ -33,10 +33,13 @@
 #include <deal.II/lac/solver_qmrs.h>
 #include <deal.II/lac/precondition.h>
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+check_solve (SOLVER             &solver,
+             const MATRIX       &A,
+             VectorType         &u,
+             VectorType         &f,
+             const PRECONDITION &P)
 {
   u = 0.;
   f = 1.;
@@ -50,10 +53,13 @@ check_solve( SOLVER &solver, const MATRIX &A,
     }
 }
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 void
-check_Tsolve(SOLVER &solver, const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+check_Tsolve (SOLVER             &solver,
+              const MATRIX       &A,
+              VectorType         &u,
+              VectorType         &f,
+              const PRECONDITION &P)
 {
   u = 0.;
   f = 1.;
@@ -286,4 +292,3 @@ int main()
       check_solve(rich,A,u,f,prec_psor);
     }
 }
-

diff --git a/tests/lac/solver_memorytest.cc b/tests/lac/solver_memorytest.cc
index 4c4998c663db6e4406c8ab9c1ba513eda75419d8..935afb87429ed48b685c59f18f5dd2dce7cc8b7f 100644 (file)
--- a/tests/lac/solver_memorytest.cc
+++ b/tests/lac/solver_memorytest.cc
@@ -39,10 +39,12 @@
 #include <deal.II/lac/solver_qmrs.h>
 #include <deal.II/lac/precondition.h>
 
-template<class SOLVER, class MATRIX, class VECTOR>
+template<class SOLVER, class MATRIX, typename VectorType>
 void
-check_solve( const MATRIX &A, VECTOR &u, VECTOR &f,
-             const typename SOLVER::AdditionalData &additional_data = typename SOLVER::AdditionalData() )
+check_solve (const MATRIX &A,
+             VectorType &u,
+             VectorType &f,
+             const typename SOLVER::AdditionalData &additional_data = typename SOLVER::AdditionalData())
 {
   GrowingVectorMemory<> mem;
   SolverControl control(100, 1.e-3);
@@ -102,4 +104,3 @@ int main()
     }
 
 }
-

diff --git a/tests/lac/solver_monitor.cc b/tests/lac/solver_monitor.cc
index eec4e9ca9369326c74057e6fc74b5628706670e5..b2a888f2dc7167f061b5bb6223d817e4fbeed86a 100644 (file)
--- a/tests/lac/solver_monitor.cc
+++ b/tests/lac/solver_monitor.cc
@@ -56,10 +56,13 @@ SolverControl::State monitor_mean (const unsigned int    iteration,
 
 
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+check_solve (SOLVER             &solver,
+             const MATRIX       &A,
+             VectorType         &u,
+             VectorType         &f,
+             const PRECONDITION &P)
 {
   u = 0.;
   f = 1.;
@@ -140,4 +143,3 @@ int main()
         }
     }
 }
-

diff --git a/tests/lac/solver_monitor_disconnect.cc b/tests/lac/solver_monitor_disconnect.cc
index c405de2544e691e731c38da3536b20ca087ab573..e95b7d7fd8e24ea7b2e1e408a2c39f2922617851 100644 (file)
--- a/tests/lac/solver_monitor_disconnect.cc
+++ b/tests/lac/solver_monitor_disconnect.cc
@@ -57,10 +57,13 @@ SolverControl::State monitor_mean (const unsigned int    iteration,
 
 
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+check_solve (SOLVER             &solver,
+             const MATRIX       &A,
+             VectorType         &u,
+             VectorType         &f,
+             const PRECONDITION &P)
 {
   u = 0.;
   f = 1.;
@@ -137,4 +140,3 @@ int main()
       cg_c1.disconnect();
     }
 }
-

diff --git a/tests/lac/solver_relaxation_01.cc b/tests/lac/solver_relaxation_01.cc
index 72ea3fc4f4e2016e5c30587ce4bbdd558969a3b6..dbbe821f00b2ae4c690f22a26dd83e46d234814a 100644 (file)
--- a/tests/lac/solver_relaxation_01.cc
+++ b/tests/lac/solver_relaxation_01.cc
@@ -31,10 +31,13 @@
 #include <deal.II/lac/solver_relaxation.h>
 #include <deal.II/lac/precondition.h>
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 double
-check_solve( SOLVER &solver, const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+check_solve (SOLVER             &solver,
+             const MATRIX       &A,
+             VectorType         &u,
+             VectorType         &f,
+             const PRECONDITION &P)
 {
   double result = 0.;
   u = 0.;
@@ -176,4 +179,3 @@ int main()
       check_solve(rich,A,u,f,prec_psor);
     }
 }
-

diff --git a/tests/lac/solver_relaxation_02.cc b/tests/lac/solver_relaxation_02.cc
index fe62b29e40e6b6a013817c7dd3edd718ceba61ea..785c02deffb3dedca95f24445a3266ee831b118b 100644 (file)
--- a/tests/lac/solver_relaxation_02.cc
+++ b/tests/lac/solver_relaxation_02.cc
@@ -32,10 +32,13 @@
 #include <deal.II/lac/precondition_block.h>
 #include <deal.II/lac/relaxation_block.h>
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 double
-check_solve( SOLVER &solver, const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+check_solve (SOLVER             &solver,
+             const MATRIX       &A,
+             VectorType         &u,
+             VectorType         &f,
+             const PRECONDITION &P)
 {
   double result = 0.;
   u = 0.;
@@ -151,4 +154,3 @@ int main()
         }
     }
 }
-

diff --git a/tests/lac/solver_relaxation_03.cc b/tests/lac/solver_relaxation_03.cc
index 131520c3aff3cbd1b39e0341133d02ad374eb3c8..e332339d16da36355d498d98b38403f2641b907d 100644 (file)
--- a/tests/lac/solver_relaxation_03.cc
+++ b/tests/lac/solver_relaxation_03.cc
@@ -33,10 +33,13 @@
 #include <deal.II/lac/precondition_block.h>
 #include <deal.II/lac/relaxation_block.h>
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 double
-check_solve( SOLVER &solver, const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+check_solve (SOLVER             &solver,
+             const MATRIX       &A,
+             VectorType         &u,
+             VectorType         &f,
+             const PRECONDITION &P)
 {
   double result = 0.;
   u = 0.;
@@ -207,4 +210,3 @@ int main()
         }
     }
 }
-

diff --git a/tests/lac/solver_selector_01.cc b/tests/lac/solver_selector_01.cc
index bf857718c39ed2311c3234347e141c17bbf1fc4f..c3a5aab4f37ddbfb46aa67b4eaf71800d894fe9f 100644 (file)
--- a/tests/lac/solver_selector_01.cc
+++ b/tests/lac/solver_selector_01.cc
@@ -26,9 +26,9 @@
 
 #include <fstream>
 
-template <class MATRIX, class VECTOR>
+template <class MATRIX, typename VectorType>
 void
-check(const MATRIX &A, const VECTOR &f)
+check (const MATRIX &A, const VectorType &f)
 {
   std::vector<std::string> names;
   names.push_back("cg");
@@ -38,11 +38,11 @@ check(const MATRIX &A, const VECTOR &f)
 
   ReductionControl cont1(100, 0., 1.e-4);
   SolverControl cont2(100, 1.e-7);
-  SolverSelector<VECTOR> solver;
+  SolverSelector<VectorType> solver;
   PreconditionSSOR<SparseMatrix<double> > pre;
   pre.initialize(A);
 
-  VECTOR u;
+  VectorType u;
   u.reinit(f);
 
   std::vector<std::string>::const_iterator name;

diff --git a/tests/lac/solver_selector_02.cc b/tests/lac/solver_selector_02.cc
index 43d115cf1cf2ac01d2b84e644a2fa3e1da6f7846..b92608e1993fcd9988bc6c113839773f9b6b031e 100644 (file)
--- a/tests/lac/solver_selector_02.cc
+++ b/tests/lac/solver_selector_02.cc
@@ -41,9 +41,9 @@ public:
 
 
 
-template <class MATRIX, class VECTOR>
+template <class MATRIX, typename VectorType>
 void
-check(const MATRIX &A, const VECTOR &f)
+check(const MATRIX &A, const VectorType &f)
 {
   std::vector<std::string> names;
   names.push_back("cg");
@@ -52,11 +52,11 @@ check(const MATRIX &A, const VECTOR &f)
   names.push_back("fgmres");
 
   MySolverControl mycont;
-  SolverSelector<VECTOR> solver;
+  SolverSelector<VectorType> solver;
   PreconditionSSOR<SparseMatrix<double> > pre;
   pre.initialize(A);
 
-  VECTOR u;
+  VectorType u;
   u.reinit(f);
 
   std::vector<std::string>::const_iterator name;

diff --git a/tests/lac/solver_signals.cc b/tests/lac/solver_signals.cc
index f8c4ccb49b770143697968aac85d9e86fc91e925..695ec589ae7bfb988af1e6a28438f38622ed92be 100644 (file)
--- a/tests/lac/solver_signals.cc
+++ b/tests/lac/solver_signals.cc
@@ -56,10 +56,13 @@ void output_eigenvalues(const std::vector<NUMBER> &eigenvalues,const std::string
   deallog << std::endl;
 }
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 void
-check_solve( SOLVER &solver, const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+check_solve(SOLVER             &solver,
+            const MATRIX       &A,
+            VectorType         &u,
+            VectorType         &f,
+            const PRECONDITION &P)
 {
   u = 0.;
   f = 1.;
@@ -134,4 +137,3 @@ int main()
     }
 
 }
-

diff --git a/tests/lac/vector_memory.cc b/tests/lac/vector_memory.cc
index 23bee7d9632328d3775db47e006c19618aa2f2c1..f458c61d46fef609206897f441f6e17d85cf090c 100644 (file)
--- a/tests/lac/vector_memory.cc
+++ b/tests/lac/vector_memory.cc
@@ -24,27 +24,27 @@
 
 using namespace dealii;
 
-template<class VECTOR>
+template<typename VectorType>
 void
 test_leak()
 {
-  GrowingVectorMemory<VECTOR> mem;
-  VECTOR *v = mem.alloc();
+  GrowingVectorMemory<VectorType> mem;
+  VectorType *v = mem.alloc();
   v->reinit(5);
 }
 
 
-template<class VECTOR>
+template<typename VectorType>
 void
 test_stat()
 {
-  GrowingVectorMemory<VECTOR> mem(1, true);
-  VECTOR *v1 = mem.alloc();
-  VECTOR *v2 = mem.alloc();
-  VECTOR *v3 = mem.alloc();
-  VECTOR *v4 = mem.alloc();
-  VECTOR *v5 = mem.alloc();
-  VECTOR *v6 = mem.alloc();
+  GrowingVectorMemory<VectorType> mem(1, true);
+  VectorType *v1 = mem.alloc();
+  VectorType *v2 = mem.alloc();
+  VectorType *v3 = mem.alloc();
+  VectorType *v4 = mem.alloc();
+  VectorType *v5 = mem.alloc();
+  VectorType *v6 = mem.alloc();
   v1->reinit(5);
   v2->reinit(5);
   v3->reinit(5);

diff --git a/tests/trilinos/deal_solver_01.cc b/tests/trilinos/deal_solver_01.cc
index 5a94be72e4a51109eec883db57a98c6bf9f6dc5f..65ecba6476d6de306320bfa4d31bf008baf60b9c 100644 (file)
--- a/tests/trilinos/deal_solver_01.cc
+++ b/tests/trilinos/deal_solver_01.cc
@@ -37,12 +37,14 @@
 #include <deal.II/lac/vector_memory.h>
 #include <typeinfo>
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 void
-check_solve( SOLVER &solver,
+check_solve (SOLVER              &solver,
              const SolverControl &solver_control,
-             const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+             const MATRIX        &A,
+             VectorType          &u,
+             VectorType          &f,
+             const PRECONDITION  &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
 
@@ -103,4 +105,3 @@ int main(int argc, char **argv)
     check_solve (solver, control, A,u,f, preconditioner);
   }
 }
-

diff --git a/tests/trilinos/deal_solver_02.cc b/tests/trilinos/deal_solver_02.cc
index 073cdb75285af5e65d4d76df904ff1f6da1be034..67ac684037013543fb5286a208363094f5ee5a98 100644 (file)
--- a/tests/trilinos/deal_solver_02.cc
+++ b/tests/trilinos/deal_solver_02.cc
@@ -39,12 +39,14 @@
 #include <deal.II/lac/vector_memory.h>
 #include <typeinfo>
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 void
-check_solve( SOLVER &solver,
+check_solve (SOLVER              &solver,
              const SolverControl &solver_control,
-             const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+             const MATRIX        &A,
+             VectorType          &u,
+             VectorType          &f,
+             const PRECONDITION  &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
 
@@ -104,4 +106,3 @@ int main(int argc, char **argv)
     check_solve (solver, control, A,u,f, preconditioner);
   }
 }
-

diff --git a/tests/trilinos/deal_solver_03.cc b/tests/trilinos/deal_solver_03.cc
index 37ac44b28c14d9c78da833fe5f9807fc750e5aa8..0f4b136d8a455adac063c16c2d0eb9ed29a71311 100644 (file)
--- a/tests/trilinos/deal_solver_03.cc
+++ b/tests/trilinos/deal_solver_03.cc
@@ -39,12 +39,14 @@
 #include <deal.II/lac/vector_memory.h>
 #include <typeinfo>
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 void
-check_solve( SOLVER &solver,
+check_solve (SOLVER &solver,
              const SolverControl &solver_control,
              const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+             VectorType &u,
+             VectorType &f,
+             const PRECONDITION &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
 
@@ -105,4 +107,3 @@ int main(int argc, char **argv)
     check_solve (solver, control, A,u,f, preconditioner);
   }
 }
-

diff --git a/tests/trilinos/deal_solver_04.cc b/tests/trilinos/deal_solver_04.cc
index afa0020f0a810a5dcf768c7a55a6f0c50a7f306c..044ef1ceeb7da091af4ff2ba9c6fa3eabba7e17e 100644 (file)
--- a/tests/trilinos/deal_solver_04.cc
+++ b/tests/trilinos/deal_solver_04.cc
@@ -38,12 +38,14 @@
 #include <deal.II/lac/vector_memory.h>
 #include <typeinfo>
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 void
-check_solve( SOLVER &solver,
+check_solve (SOLVER              &solver,
              const SolverControl &solver_control,
-             const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+             const MATRIX        &A,
+             VectorType          &u,
+             VectorType          &f,
+             const PRECONDITION  &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
 
@@ -104,4 +106,3 @@ int main(int argc, char **argv)
     check_solve (solver, control, A,u,f, preconditioner);
   }
 }
-

diff --git a/tests/trilinos/deal_solver_05.cc b/tests/trilinos/deal_solver_05.cc
index 5db7c660acae8ed889ff3c3147a045688058d8df..6ebb71eef7f6107439aabcf8222ca5d9701a91d0 100644 (file)
--- a/tests/trilinos/deal_solver_05.cc
+++ b/tests/trilinos/deal_solver_05.cc
@@ -37,12 +37,14 @@
 #include <deal.II/lac/vector_memory.h>
 #include <typeinfo>
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 void
-check_solve( SOLVER &solver,
+check_solve (SOLVER              &solver,
              const SolverControl &solver_control,
-             const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+             const MATRIX        &A,
+             VectorType          &u,
+             VectorType          &f,
+             const PRECONDITION  &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
 
@@ -103,4 +105,3 @@ int main(int argc, char **argv)
     check_solve (solver, control, A,u,f, preconditioner);
   }
 }
-

diff --git a/tests/trilinos/deal_solver_06.cc b/tests/trilinos/deal_solver_06.cc
index bf1a77d9ecb234c3b9b4c5bca9679bacf7b33f0f..f53512a8ae0bc29490684a85fae3a21698fd14e3 100644 (file)
--- a/tests/trilinos/deal_solver_06.cc
+++ b/tests/trilinos/deal_solver_06.cc
@@ -37,12 +37,14 @@
 #include <deal.II/lac/vector_memory.h>
 #include <typeinfo>
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 void
-check_solve( SOLVER &solver,
+check_solve (SOLVER              &solver,
              const SolverControl &solver_control,
-             const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+             const MATRIX        &A,
+             VectorType          &u,
+             VectorType          &f,
+             const PRECONDITION  &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
 
@@ -102,4 +104,3 @@ int main(int argc, char **argv)
     check_solve (solver, control, A,u,f, preconditioner);
   }
 }
-

diff --git a/tests/trilinos/solver_03.cc b/tests/trilinos/solver_03.cc
index a82cd87d2305b3afa78c83793a7e42d29b2d10bd..300c0a235b0b405ff0f430f1d355541f108581b4 100644 (file)
--- a/tests/trilinos/solver_03.cc
+++ b/tests/trilinos/solver_03.cc
@@ -32,12 +32,14 @@
 #include <deal.II/lac/vector_memory.h>
 #include <typeinfo>
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 void
-check_solve( SOLVER &solver,
+check_solve (SOLVER              &solver,
              const SolverControl &solver_control,
-             const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+             const MATRIX        &A,
+             VectorType          &u,
+             VectorType          &f,
+             const PRECONDITION  &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
 
@@ -98,4 +100,3 @@ int main(int argc, char **argv)
     check_solve (solver, control, A,u,f, preconditioner);
   }
 }
-

diff --git a/tests/trilinos/solver_05.cc b/tests/trilinos/solver_05.cc
index a3c2d09875b281d3c97289a7985ed6d1c2d06c6b..64c665545d2ebfc0395dba39dda3d286e8566e5b 100644 (file)
--- a/tests/trilinos/solver_05.cc
+++ b/tests/trilinos/solver_05.cc
@@ -32,12 +32,14 @@
 #include <deal.II/lac/vector_memory.h>
 #include <typeinfo>
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 void
-check_solve( SOLVER &solver,
+check_solve (SOLVER              &solver,
              const SolverControl &solver_control,
-             const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+             const MATRIX        &A,
+             VectorType          &u,
+             VectorType          &f,
+             const PRECONDITION  &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
 
@@ -98,4 +100,3 @@ int main(int argc, char **argv)
     check_solve (solver, control, A,u,f, preconditioner);
   }
 }
-

diff --git a/tests/trilinos/solver_07.cc b/tests/trilinos/solver_07.cc
index ed9227cc6eec426d3900f784028770245dafe1a7..7b03471878db77c31c6feb639525432c7cca2f91 100644 (file)
--- a/tests/trilinos/solver_07.cc
+++ b/tests/trilinos/solver_07.cc
@@ -32,12 +32,14 @@
 #include <deal.II/lac/vector_memory.h>
 #include <typeinfo>
 
-template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+template<class SOLVER, class MATRIX, typename VectorType, class PRECONDITION>
 void
-check_solve( SOLVER &solver,
+check_solve (SOLVER              &solver,
              const SolverControl &solver_control,
-             const MATRIX &A,
-             VECTOR &u, VECTOR &f, const PRECONDITION &P)
+             const MATRIX        &A,
+             VectorType          &u,
+             VectorType          &f,
+             const PRECONDITION  &P)
 {
   deallog << "Solver type: " << typeid(solver).name() << std::endl;
 
@@ -98,4 +100,3 @@ int main(int argc, char **argv)
   }
 
 }
-

diff --git a/tests/umfpack/umfpack_04.cc b/tests/umfpack/umfpack_04.cc
index 05763903dfb5142dca74f09d162d13163fcebdec..51ca7d08af6ae106fc3150921dea95dc0b80fb79 100644 (file)
--- a/tests/umfpack/umfpack_04.cc
+++ b/tests/umfpack/umfpack_04.cc
@@ -44,8 +44,8 @@
 #include <deal.II/numerics/vector_tools.h>
 #include <deal.II/numerics/matrix_tools.h>
 
-template <int dim, typename MATRIX, typename VECTOR>
-void assemble_laplace (MATRIX &B, VECTOR &bb, DoFHandler<dim> &dof_handler, FiniteElement<dim> &fe)
+template <int dim, typename MATRIX, typename VectorType>
+void assemble_laplace (MATRIX &B, VectorType &bb, DoFHandler<dim> &dof_handler, FiniteElement<dim> &fe)
 {
   QGauss<dim>  quadrature_formula(2);
   FEValues<dim> fe_values (fe, quadrature_formula,